/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema/SemaExpr.cpp

Bug Summary

File:	clang/lib/Sema/SemaExpr.cpp
Warning:	line 10229, column 46 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaExpr.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D 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-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Sema/SemaExpr.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/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/RecursiveASTVisitor.h"
29#include "clang/AST/TypeLoc.h"
30#include "clang/Basic/Builtins.h"
31#include "clang/Basic/PartialDiagnostic.h"
32#include "clang/Basic/SourceManager.h"
33#include "clang/Basic/TargetInfo.h"
34#include "clang/Lex/LiteralSupport.h"
35#include "clang/Lex/Preprocessor.h"
36#include "clang/Sema/AnalysisBasedWarnings.h"
37#include "clang/Sema/DeclSpec.h"
38#include "clang/Sema/DelayedDiagnostic.h"
39#include "clang/Sema/Designator.h"
40#include "clang/Sema/Initialization.h"
41#include "clang/Sema/Lookup.h"
42#include "clang/Sema/Overload.h"
43#include "clang/Sema/ParsedTemplate.h"
44#include "clang/Sema/Scope.h"
45#include "clang/Sema/ScopeInfo.h"
46#include "clang/Sema/SemaFixItUtils.h"
47#include "clang/Sema/SemaInternal.h"
48#include "clang/Sema/Template.h"
49#include "llvm/ADT/STLExtras.h"
50#include "llvm/ADT/StringExtras.h"
51#include "llvm/Support/ConvertUTF.h"
52#include "llvm/Support/SaveAndRestore.h"

54using namespace clang;
55using namespace sema;
56using llvm::RoundingMode;

58/// Determine whether the use of this declaration is valid, without
59/// emitting diagnostics.
60bool 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;
92}

94static 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;
  }
}
106}

108/// Emit a note explaining that this function is deleted.
109void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
assert(Decl && Decl->isDeleted())(static_cast<void> (0));

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;
129}

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

141/// Check whether we're in an extern inline function and referring to a
142/// variable or function with internal linkage (C11 6.7.4p3).
143///
144/// This is only a warning because we used to silently accept this code, but
145/// in many cases it will not behave correctly. This is not enabled in C++ mode
146/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
147/// and so while there may still be user mistakes, most of the time we can't
148/// prove that there are errors.
149static 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;
191}

193void 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 ");
}
202}

204/// Determine whether the use of this declaration is valid, and
205/// emit any corresponding diagnostics.
206///
207/// This routine diagnoses various problems with referencing
208/// declarations that can occur when using a declaration. For example,
209/// it might warn if a deprecated or unavailable declaration is being
210/// used, or produce an error (and return true) if a C++0x deleted
211/// function is being used.
212///
213/// \returns true if there was an error (this declaration cannot be
214/// referenced), false otherwise.
215///
216bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
                           const ObjCInterfaceDecl *UnknownObjCClass,
                           bool ObjCPropertyAccess,
                           bool AvoidPartialAvailabilityChecks,
                           ObjCInterfaceDecl *ClassReceiver) {
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 (FD->getTrailingRequiresClause()) {
    ConstraintSatisfaction Satisfaction;
    if (CheckFunctionConstraints(FD, Satisfaction, Loc))
      // 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 (getLangOpts().SYCLIsDevice && !checkSYCLDeviceFunction(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
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 (LangOpts.SYCLIsDevice || (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)) {
  if (auto *VD = dyn_cast<ValueDecl>(D))
    checkDeviceDecl(VD, Loc);

  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;
391}

393/// DiagnoseSentinelCalls - This routine checks whether a call or
394/// message-send is to a declaration with the sentinel attribute, and
395/// if so, it checks that the requirements of the sentinel are
396/// satisfied.
397void 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<void> (0));
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);
486}

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

492//===----------------------------------------------------------------------===//
493//  Standard Promotions and Conversions
494//===----------------------------------------------------------------------===//

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

QualType Ty = E->getType();
assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type")(static_cast<void> (0));

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;
537}

539static 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));
  }
}
562}

564static 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);
    }
  }
619}

621ExprResult Sema::DefaultLvalueConversion(Expr *E) {
// Handle any placeholder expressions which made it here.
if (E->getType()->isPlaceholderType()) {
  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<void> (0));

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

731ExprResult 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;
739}

741/// CallExprUnaryConversions - a special case of an unary conversion
742/// performed on a function designator of a call expression.
743ExprResult 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();
758}

760/// UsualUnaryConversions - Performs various conversions that are common to most
761/// operators (C99 6.3). The conversions of array and function types are
762/// sometimes suppressed. For example, the array->pointer conversion doesn't
763/// apply if the array is an argument to the sizeof or address (&) operators.
764/// In these instances, this routine should *not* be called.
765ExprResult 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<void> (0));

// 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 (Ty->isPromotableIntegerType()) {
    QualType PT = Context.getPromotedIntegerType(Ty);
    E = ImpCastExprToType(E, PT, CK_IntegralCast).get();
    return E;
  }
}
return E;
808}

810/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
811/// do not have a prototype. Arguments that have type float or __fp16
812/// are promoted to double. All other argument types are converted by
813/// UsualUnaryConversions().
814ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
QualType Ty = E->getType();
assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type")(static_cast<void> (0));

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<void> (0))
         "Unexpected typesize for LongLongTy")(static_cast<void> (0));
}

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

876/// Determine the degree of POD-ness for an expression.
877/// Incomplete types are considered POD, since this check can be performed
878/// when we're in an unevaluated context.
879Sema::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 (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;
927}

929void 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);
  LLVM_FALLTHROUGH[[gnu::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;
}
972}

974/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
975/// will create a trap if the resulting type is not a POD type.
976ExprResult 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(),
                                  None, 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;
1037}

1039/// Converts an integer to complex float type.  Helper function of
1040/// UsualArithmeticConversions()
1041///
1042/// \return false if the integer expression is an integer type and is
1043/// successfully converted to the complex type.
1044static 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 = cast<ComplexType>(ComplexTy)->getElementType();
  IntExpr = S.ImpCastExprToType(IntExpr.get(), fpTy, CK_IntegralToFloating);
  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                CK_FloatingRealToComplex);
} else {
  assert(IntTy->isComplexIntegerType())(static_cast<void> (0));
  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                CK_IntegralComplexToFloatingComplex);
}
return false;
1062}

1064/// Handle arithmetic conversion with complex types.  Helper function of
1065/// UsualArithmeticConversions()
1066static QualType handleComplexFloatConversion(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;

// This handles complex/complex, complex/float, or float/complex.
// When both operands are complex, the shorter operand is converted to the
// type of the longer, and that is the type of the result. This corresponds
// to what is done when combining two real floating-point operands.
// The fun begins when size promotion occur across type domains.
// From H&S 6.3.4: When one operand is complex and the other is a real
// floating-point type, the less precise type is converted, within it's
// real or complex domain, to the precision of the other type. For example,
// when combining a "long double" with a "double _Complex", the
// "double _Complex" is promoted to "long double _Complex".

// Compute the rank of the two types, regardless of whether they are complex.
int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);

auto *LHSComplexType = dyn_cast<ComplexType>(LHSType);
auto *RHSComplexType = dyn_cast<ComplexType>(RHSType);
QualType LHSElementType =
    LHSComplexType ? LHSComplexType->getElementType() : LHSType;
QualType RHSElementType =
    RHSComplexType ? RHSComplexType->getElementType() : RHSType;

QualType ResultType = S.Context.getComplexType(LHSElementType);
if (Order < 0) {
  // Promote the precision of the LHS if not an assignment.
  ResultType = S.Context.getComplexType(RHSElementType);
  if (!IsCompAssign) {
    if (LHSComplexType)
      LHS =
          S.ImpCastExprToType(LHS.get(), ResultType, CK_FloatingComplexCast);
    else
      LHS = S.ImpCastExprToType(LHS.get(), RHSElementType, CK_FloatingCast);
  }
} else if (Order > 0) {
  // Promote the precision of the RHS.
  if (RHSComplexType)
    RHS = S.ImpCastExprToType(RHS.get(), ResultType, CK_FloatingComplexCast);
  else
    RHS = S.ImpCastExprToType(RHS.get(), LHSElementType, CK_FloatingCast);
}
return ResultType;
1118}

1120/// Handle arithmetic conversion from integer to float.  Helper function
1121/// of UsualArithmeticConversions()
1122static 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<void> (0));
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;
1149}

1151/// Handle arithmethic conversion with floating point types.  Helper
1152/// function of UsualArithmeticConversions()
1153static 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<void> (0));
  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<void> (0));
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                  /*ConvertFloat=*/ true,
                                  /*ConvertInt=*/!IsCompAssign);
1198}

1200/// Diagnose attempts to convert between __float128 and long double if
1201/// there is no support for such conversion. Helper function of
1202/// UsualArithmeticConversions().
1203static bool unsupportedTypeConversion(const Sema &S, QualType LHSType,
                                    QualType RHSType) {
/*  No issue converting if at least one of the types is not a floating point
    type or the two types have the same rank.
*/
if (!LHSType->isFloatingType() || !RHSType->isFloatingType() ||
    S.Context.getFloatingTypeOrder(LHSType, RHSType) == 0)
  return false;

assert(LHSType->isFloatingType() && RHSType->isFloatingType() &&(static_cast<void> (0))
       "The remaining types must be floating point types.")(static_cast<void> (0));

auto *LHSComplex = LHSType->getAs<ComplexType>();
auto *RHSComplex = RHSType->getAs<ComplexType>();

QualType LHSElemType = LHSComplex ?
  LHSComplex->getElementType() : LHSType;
QualType RHSElemType = RHSComplex ?
  RHSComplex->getElementType() : RHSType;

// No issue if the two types have the same representation
if (&S.Context.getFloatTypeSemantics(LHSElemType) ==
    &S.Context.getFloatTypeSemantics(RHSElemType))
  return false;

bool Float128AndLongDouble = (LHSElemType == S.Context.Float128Ty &&
                              RHSElemType == S.Context.LongDoubleTy);
Float128AndLongDouble |= (LHSElemType == S.Context.LongDoubleTy &&
                          RHSElemType == S.Context.Float128Ty);

// We've handled the situation where __float128 and long double have the same
// representation. We allow all conversions for all possible long double types
// except PPC's double double.
return Float128AndLongDouble &&
  (&S.Context.getFloatTypeSemantics(S.Context.LongDoubleTy) ==
   &llvm::APFloat::PPCDoubleDouble());
1239}

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

1243namespace {
1244/// These helper callbacks are placed in an anonymous namespace to
1245/// permit their use as function template parameters.
1246ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1248}

1250ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
                           CK_IntegralComplexCast);
1253}
1254}

1256/// Handle integer arithmetic conversions.  Helper function of
1257/// UsualArithmeticConversions()
1258template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1259static 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;
}
1305}

1307/// Handle conversions with GCC complex int extension.  Helper function
1308/// of UsualArithmeticConversions()
1309static 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<void> (0));

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;
1350}

1352/// Return the rank of a given fixed point or integer type. The value itself
1353/// doesn't matter, but the values must be increasing with proper increasing
1354/// rank as described in N1169 4.1.1.
1355static unsigned GetFixedPointRank(QualType Ty) {
const auto *BTy = Ty->getAs<BuiltinType>();
assert(BTy && "Expected a builtin type.")(static_cast<void> (0));

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

1397/// handleFixedPointConversion - Fixed point operations between fixed
1398/// point types and integers or other fixed point types do not fall under
1399/// usual arithmetic conversion since these conversions could result in loss
1400/// of precsision (N1169 4.1.4). These operations should be calculated with
1401/// the full precision of their result type (N1169 4.1.6.2.1).
1402static QualType handleFixedPointConversion(Sema &S, QualType LHSTy,
                                         QualType RHSTy) {
assert((LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) &&(static_cast<void> (0))
       "Expected at least one of the operands to be a fixed point type")(static_cast<void> (0));
assert((LHSTy->isFixedPointOrIntegerType() ||(static_cast<void> (0))
        RHSTy->isFixedPointOrIntegerType()) &&(static_cast<void> (0))
       "Special fixed point arithmetic operation conversions are only "(static_cast<void> (0))
       "applied to ints or other fixed point types")(static_cast<void> (0));

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

1439/// Check that the usual arithmetic conversions can be performed on this pair of
1440/// expressions that might be of enumeration type.
1441static 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;
}
1493}

1495/// UsualArithmeticConversions - Performs various conversions that are common to
1496/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
1497/// routine returns the first non-arithmetic type found. The client is
1498/// responsible for emitting appropriate error diagnostics.
1499QualType 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 =
  Context.getCanonicalType(LHS.get()->getType()).getUnqualifiedType();
QualType RHSType =
  Context.getCanonicalType(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 (LHSType == RHSType)
  return LHSType;

// 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 (LHSType->isPromotableIntegerType())
  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 (LHSType == RHSType)
  return LHSType;

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

// Diagnose attempts to convert between __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 handleComplexFloatConversion(*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);
1576}

1578//===----------------------------------------------------------------------===//
1579//  Semantic Analysis for various Expression Types
1580//===----------------------------------------------------------------------===//


1583ExprResult
1584Sema::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<void> (0));

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::makeArrayRef(Types, NumAssocs),
                                           ArgExprs);
delete [] Types;
return ER;
1607}

1609ExprResult
1610Sema::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<void> (0));

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

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

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

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;

      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;
for (unsigned i = 0; i < NumAssocs; ++i) {
  if (!Types[i])
    DefaultIndex = i;
  else if (Context.typesAreCompatible(ControllingExpr->getType(),
                                      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);
1752}

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

1762/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1763/// the corresponding cooked (non-raw) literal operator, and build a call to it.
1764static 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<void> (0));

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::makeArrayRef(ArgTy, Args.size()),
                            /*AllowRaw*/ false, /*AllowTemplate*/ false,
                            /*AllowStringTemplatePack*/ false,
                            /*DiagnoseMissing*/ true) == Sema::LOLR_Error)
  return ExprError();

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

1793/// ActOnStringLiteral - The specified tokens were lexed as pasted string
1794/// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
1795/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1796/// multiple tokens.  However, the common case is that StringToks points to one
1797/// string.
1798///
1799ExprResult
1800Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
assert(!StringToks.empty() && "Must have at least one string!")(static_cast<void> (0));

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::Ascii;
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, None, 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, None, StringTokLocs.back(),
                                  &ExplicitArgs);
}
case LOLR_Raw:
case LOLR_ErrorNoDiagnostic:
  llvm_unreachable("unexpected literal operator lookup result")__builtin_unreachable();
case LOLR_Error:
  return ExprError();
}
llvm_unreachable("unexpected literal operator lookup result")__builtin_unreachable();
1940}

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

1950DeclRefExpr *
1951Sema::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);
1960}

1962// CUDA/HIP: Check whether a captured reference variable is referencing a
1963// host variable in a device or host device lambda.
1964static bool isCapturingReferenceToHostVarInCUDADeviceLambda(const Sema &S,
                                                          VarDecl *VD) {
if (!S.getLangOpts().CUDA || !VD->hasInit())
  return false;
assert(VD->getType()->isReferenceType())(static_cast<void> (0));

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

1991NonOdrUseReason 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;
2017}

2019/// BuildDeclRefExpr - Build an expression that references a
2020/// declaration that does not require a closure capture.
2021DeclRefExpr *
2022Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                     const DeclarationNameInfo &NameInfo,
                     NestedNameSpecifierLoc NNS, NamedDecl *FoundD,
                     SourceLocation TemplateKWLoc,
                     const TemplateArgumentListInfo *TemplateArgs) {
bool RefersToCapturedVariable =
    isa<VarDecl>(D) &&
    NeedToCaptureVariable(cast<VarDecl>(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 (auto *FPT = Ty->getAs<FunctionProtoType>()) {
  if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
    if (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);

FieldDecl *FD = dyn_cast<FieldDecl>(D);
if (IndirectFieldDecl *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 (auto *BD = dyn_cast<BindingDecl>(D))
  if (auto *BE = BD->getBinding())
    E->setObjectKind(BE->getObjectKind());

return E;
2077}

2079/// Decomposes the given name into a DeclarationNameInfo, its location, and
2080/// possibly a list of template arguments.
2081///
2082/// If this produces template arguments, it is permitted to call
2083/// DecomposeTemplateName.
2084///
2085/// This actually loses a lot of source location information for
2086/// non-standard name kinds; we should consider preserving that in
2087/// some way.
2088void
2089Sema::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;
}
2109}

2111static 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));
2142}

2144/// Diagnose a lookup that found results in an enclosing class during error
2145/// recovery. This usually indicates that the results were found in a dependent
2146/// base class that could not be searched as part of a template definition.
2147/// Always issues a diagnostic (though this may be only a warning in MS
2148/// compatibility mode).
2149///
2150/// Return \c true if the error is unrecoverable, or \c false if the caller
2151/// should attempt to recover using these lookup results.
2152bool Sema::DiagnoseDependentMemberLookup(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;
CXXMethodDecl *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 (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;
2209}

2211/// Diagnose an empty lookup.
2212///
2213/// \return false if new lookup candidates were found
2214bool 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<void> (0))
         "Diagnosing an empty lookup with explicit template args!")(static_cast<void> (0));
  *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;
2378}

2380/// In Microsoft mode, if we are inside a template class whose parent class has
2381/// dependent base classes, and we can't resolve an unqualified identifier, then
2382/// assume the identifier is a member of a dependent base class.  We can only
2383/// recover successfully in static methods, instance methods, and other contexts
2384/// where 'this' is available.  This doesn't precisely match MSVC's
2385/// instantiation model, but it's close enough.
2386static Expr *
2387recoverFromMSUnqualifiedLookup(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);
2425}

2427ExprResult
2428Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                      bool HasTrailingLParen, bool IsAddressOfOperand,
                      CorrectionCandidateCallback *CCC,
                      bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&(static_cast<void> (0))
       "cannot be direct & operand and have a trailing lparen")(static_cast<void> (0));
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 (legal in C90,
// extension in C99, forbidden in C++).
if (R.empty() && HasTrailingLParen && II && !getLangOpts().CPlusPlus) {
  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<void> (0))
         "Typo correction callback misconfigured")(static_cast<void> (0));
  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,
                          None, &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<void> (0))
         "DiagnoseEmptyLookup returned false but added no results")(static_cast<void> (0));

  // 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<void> (0));

// 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<void> (0))
           "There should only be one declaration found.")(static_cast<void> (0));
  }

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

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

2675/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2676/// declaration name, generally during template instantiation.
2677/// There's a large number of things which don't need to be done along
2678/// this path.
2679ExprResult Sema::BuildQualifiedDeclarationNameExpr(
  CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo,
  bool IsAddressOfOperand, const Scope *S, TypeSourceInfo **RecoveryTSI) {
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);
2758}

2760/// The parser has read a name in, and Sema has detected that we're currently
2761/// inside an ObjC method. Perform some additional checks and determine if we
2762/// should form a reference to an ivar.
2763///
2764/// Ideally, most of this would be done by lookup, but there's
2765/// actually quite a lot of extra work involved.
2766DeclResult 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);
2837}

2839ExprResult Sema::BuildIvarRefExpr(Scope *S, SourceLocation Loc,
                                ObjCIvarDecl *IV) {
ObjCMethodDecl *CurMethod = getCurMethodDecl();
assert(CurMethod && CurMethod->isInstanceMethod() &&(static_cast<void> (0))
       "should not reference ivar from this context")(static_cast<void> (0));

ObjCInterfaceDecl *IFace = CurMethod->getClassInterface();
assert(IFace && "should not reference ivar from this context")(static_cast<void> (0));

// 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)
  if (const BlockDecl *BD = CurContext->getInnermostBlockDecl())
    ImplicitlyRetainedSelfLocs.push_back({Loc, BD});

return Result;
2896}

2898/// The parser has read a name in, and Sema has detected that we're currently
2899/// inside an ObjC method. Perform some additional checks and determine if we
2900/// should form a reference to an ivar. If so, build an expression referencing
2901/// that ivar.
2902ExprResult
2903Sema::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);
2918}

2920/// Cast a base object to a member's actual type.
2921///
2922/// There are two relevant checks:
2923///
2924/// C++ [class.access.base]p7:
2925///
2926///   If a class member access operator [...] is used to access a non-static
2927///   data member or non-static member function, the reference is ill-formed if
2928///   the left operand [...] cannot be implicitly converted to a pointer to the
2929///   naming class of the right operand.
2930///
2931/// C++ [expr.ref]p7:
2932///
2933///   If E2 is a non-static data member or a non-static member function, the
2934///   program is ill-formed if the class of which E2 is directly a member is an
2935///   ambiguous base (11.8) of the naming class (11.9.3) of E2.
2936///
2937/// Note that the latter check does not consider access; the access of the
2938/// "real" base class is checked as appropriate when checking the access of the
2939/// member name.
2940ExprResult
2941Sema::PerformObjectMemberConversion(Expr *From,
                                  NestedNameSpecifier *Qualifier,
                                  NamedDecl *FoundDecl,
                                  NamedDecl *Member) {
CXXRecordDecl *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 (CXXMethodDecl *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<void> (0));

  QualType QRecordType = QualType(QType->getAs<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);
3071}

3073bool 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 (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 (isa<FunctionDecl>(D)) {
    FunctionDecl *FDecl = cast<FunctionDecl>(D);

    // But also builtin functions.
    if (FDecl->getBuiltinID() && FDecl->isImplicit())
      return false;
  } else if (!isa<FunctionTemplateDecl>(D))
    return false;
}

return true;
3124}


3127/// Diagnoses obvious problems with the use of the given declaration
3128/// as an expression.  This is only actually called for lookups that
3129/// were not overloaded, and it doesn't promise that the declaration
3130/// will in fact be used.
3131static bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D) {
if (D->isInvalidDecl())
  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;
3151}

3153// Certain multiversion types should be treated as overloaded even when there is
3154// only one result.
3155static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R) {
assert(R.isSingleResult() && "Expected only a single result")(static_cast<void> (0));
const auto *FD = dyn_cast<FunctionDecl>(R.getFoundDecl());
return FD &&
       (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3160}

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

3196static void
3197diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
                                 ValueDecl *var, DeclContext *DC);

3200/// Complete semantic analysis for a reference to the given declaration.
3201ExprResult 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<void> (0));
assert(!isa<FunctionTemplateDecl>(D) &&(static_cast<void> (0))
       "Cannot refer unambiguously to a function template")(static_cast<void> (0));

SourceLocation Loc = NameInfo.getLoc();
if (CheckDeclInExpr(*this, Loc, D))
  return ExprError();

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 (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
  if (!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.
3260#define ABSTRACT_DECL(kind)
3261#define VALUE(type, base)
3262#define DECL(type, base) case Decl::type:
3263#include "clang/AST/DeclNodes.inc"
  llvm_unreachable("invalid value decl kind")__builtin_unreachable();

// These shouldn't make it here.
case Decl::ObjCAtDefsField:
  llvm_unreachable("forming non-member reference to ivar?")__builtin_unreachable();

// 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<void> (0));

  // 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;
  }
  LLVM_FALLTHROUGH[[gnu::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();
  // FIXME: Support lambda-capture of BindingDecls, once CWG actually
  // decides how that's supposed to work.
  auto *BD = cast<BindingDecl>(VD);
  if (BD->getDeclContext() != CurContext) {
    auto *DD = dyn_cast_or_null<VarDecl>(BD->getDecomposedDecl());
    if (DD && DD->hasLocalStorage())
      diagnoseUncapturableValueReference(*this, Loc, BD, CurContext);
  }
  break;
}

case Decl::Function: {
  if (unsigned BID = cast<FunctionDecl>(VD)->getBuiltinID()) {
    if (!Context.BuiltinInfo.isPredefinedLibFunction(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")__builtin_unreachable();

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::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;
  }
  LLVM_FALLTHROUGH[[gnu::fallthrough]];

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

return BuildDeclRefExpr(VD, type, valueKind, NameInfo, &SS, FoundD,
                        /*FIXME: TemplateKWLoc*/ SourceLocation(),
                        TemplateArgs);
3446}

3448static 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<void> (0));
Target.resize(ResultPtr - &Target[0]);
3458}

3460ExprResult 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::Ascii,
                               /*Pascal*/ false, ResTy, Loc);
  }
}

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

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

3520ExprResult 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);
3533}

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

switch (Kind) {
default: llvm_unreachable("Unknown simple primary expr!")__builtin_unreachable();
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);
3550}

3552ExprResult 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().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++

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

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

3615static 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);
3645}

3647bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {
assert(E && "Invalid expression")(static_cast<void> (0));

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;
3673}

3675ExprResult 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.
  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::Ascii,
        /*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, None, TokLoc,
                                    &ExplicitArgs);
  }
  case LOLR_StringTemplatePack:
    llvm_unreachable("unexpected literal operator lookup result")__builtin_unreachable();
  }
}

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.isNullValue() && !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;

  // 'long long' is a C99 or C++11 feature.
  if (!getLangOpts().C99 && Literal.isLongLong) {
    if (getLangOpts().CPlusPlus)
      Diag(Tok.getLocation(),
           getLangOpts().CPlusPlus11 ?
           diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
    else
      Diag(Tok.getLocation(), diag::ext_c99_longlong);
  }

  // 'z/uz' literals are a C++2b feature.
  if (Literal.isSizeT)
    Diag(Tok.getLocation(), getLangOpts().CPlusPlus
                                ? getLangOpts().CPlusPlus2b
                                      ? diag::warn_cxx20_compat_size_t_suffix
                                      : diag::ext_cxx2b_size_t_suffix
                                : diag::err_cxx2b_size_t_suffix);

  // Get the value in the widest-possible width.
  unsigned MaxWidth = Context.getTargetInfo().getIntMaxTWidth();
  llvm::APInt ResultVal(MaxWidth, 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<void> (0))
           "long long is not intmax_t?")(static_cast<void> (0));
  } 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);
      }
    }

    // Check C++2b size_t literals.
    if (Literal.isSizeT) {
      assert(!Literal.MicrosoftInteger &&(static_cast<void> (0))
             "size_t literals can't be Microsoft literals")(static_cast<void> (0));
      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;
      }
    }

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

4047ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) {
assert(E && "ActOnParenExpr() missing expr")(static_cast<void> (0));
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);
4054}

4056static 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<void> (0))
       "Scalar types should always be complete")(static_cast<void> (0));
return false;
4072}

4074static 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;
4102}

4104static 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;
4118}

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

// Now look for array decays.
ImplicitCastExpr *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();
4136}

4138/// Check the constraints on expression operands to unary type expression
4139/// and type traits.
4140///
4141/// Completes any types necessary and validates the constraints on the operand
4142/// expression. The logic mostly mirrors the type-based overload, but may modify
4143/// the expression as it completes the type for that expression through template
4144/// instantiation, etc.
4145bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
                                          UnaryExprOrTypeTrait ExprKind) {
QualType ExprTy = E->getType();
assert(!ExprTy->isReferenceType())(static_cast<void> (0));

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->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<void> (0));

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 (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
    if (ParmVarDecl *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 (BinaryOperator *BO = dyn_cast<BinaryOperator>(E->IgnoreParens())) {
    warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
                             BO->getLHS());
    warnOnSizeofOnArrayDecay(*this, BO->getOperatorLoc(), BO->getType(),
                             BO->getRHS());
  }
}

return false;
4235}

4237/// Check the constraints on operands to unary expression and type
4238/// traits.
4239///
4240/// This will complete any types necessary, and validate the various constraints
4241/// on those operands.
4242///
4243/// The UsualUnaryConversions() function is *not* called by this routine.
4244/// C99 6.3.2.1p[2-4] all state:
4245///   Except when it is the operand of the sizeof operator ...
4246///
4247/// C++ [expr.sizeof]p4
4248///   The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4249///   standard conversions are not applied to the operand of sizeof.
4250///
4251/// This policy is followed for all of the unary trait expressions.
4252bool 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;
4299}

4301static 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);
4355}

4357bool 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);
4365}

4367static void captureVariablyModifiedType(ASTContext &Context, QualType T,
                                      CapturingScopeInfo *CSI) {
assert(T->isVariablyModifiedType())(static_cast<void> (0));
assert(CSI != nullptr)(static_cast<void> (0));

// We're going to walk down into the type and look for VLA expressions.
do {
  const Type *Ty = T.getTypePtr();
  switch (Ty->getTypeClass()) {
4376#define TYPE(Class, Base)
4377#define ABSTRACT_TYPE(Class, Base)
4378#define NON_CANONICAL_TYPE(Class, Base)
4379#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4380#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4381#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::Elaborated:
  case Type::TemplateSpecialization:
  case Type::ObjCObject:
  case Type::ObjCInterface:
  case Type::ObjCObjectPointer:
  case Type::ObjCTypeParam:
  case Type::Pipe:
  case Type::ExtInt:
    llvm_unreachable("type class is never variably-modified!")__builtin_unreachable();
  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::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::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());
4470}

4472/// Build a sizeof or alignof expression given a type operand.
4473ExprResult
4474Sema::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.
return new (Context) UnaryExprOrTypeTraitExpr(
    ExprKind, TInfo, Context.getSizeType(), OpLoc, R.getEnd());
4514}

4516/// Build a sizeof or alignof expression given an expression
4517/// operand.
4518ExprResult
4519Sema::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());
4557}

4559/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
4560/// expr and the same for @c alignof and @c __alignof
4561/// Note that the ArgRange is invalid if isType is false.
4562ExprResult
4563Sema::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;
4578}

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



4616ExprResult
4617Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
                        tok::TokenKind Kind, Expr *Input) {
UnaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown unary op!")__builtin_unreachable();
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);
4632}

4634/// Diagnose if arithmetic on the given ObjC pointer is illegal.
4635///
4636/// \return true on error
4637static bool checkArithmeticOnObjCPointer(Sema &S,
                                       SourceLocation opLoc,
                                       Expr *op) {
assert(op->getType()->isObjCObjectPointerType())(static_cast<void> (0));
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;
4649}

4651static 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);
4656}

4658ExprResult
4659Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc,
                            Expr *idx, SourceLocation rbLoc) {
if (base && !base->getType().isNull() &&
    base->getType()->isSpecificPlaceholderType(BuiltinType::OMPArraySection))
  return ActOnOMPArraySectionExpr(base, lbLoc, idx, SourceLocation(),
                                  SourceLocation(), /*Length*/ nullptr,
                                  /*Stride=*/nullptr, rbLoc);

// Since this might be a postfix expression, get rid of ParenListExprs.
if (isa<ParenListExpr>(base)) {
  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->getType()->isSpecificPlaceholderType(
        BuiltinType::IncompleteMatrixIdx) &&
    !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) {
  if (CheckAndReportCommaError(idx))
    return ExprError();

  assert(matSubscriptE->isIncomplete() &&(static_cast<void> (0))
         "base has to be an incomplete matrix subscript")(static_cast<void> (0));
  return CreateBuiltinMatrixSubscriptExpr(
      matSubscriptE->getBase(), matSubscriptE->getRowIdx(), idx, 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()) {
  if (CheckAndReportCommaError(idx))
    return ExprError();

  return CreateBuiltinMatrixSubscriptExpr(base, idx, nullptr, rbLoc);
}

// A comma-expression as the index is deprecated in C++2a onwards.
if (getLangOpts().CPlusPlus20 &&
    ((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 (idx->getType()->isNonOverloadPlaceholderType()) {
  ExprResult result = CheckPlaceholderExpr(idx);
  if (result.isInvalid()) return ExprError();
  idx = result.get();
}

// Build an unanalyzed expression if either operand is type-dependent.
if (getLangOpts().CPlusPlus &&
    (base->isTypeDependent() || idx->isTypeDependent())) {
  return new (Context) ArraySubscriptExpr(base, idx, Context.DependentTy,
                                          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) {
  // Build MS property subscript expression if base is MS property reference
  // or MS property subscript.
  return new (Context) MSPropertySubscriptExpr(
      base, idx, 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()->isRecordType() ||
     (!base->getType()->isObjCObjectPointerType() &&
      idx->getType()->isRecordType()))) {
  return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx);
}

ExprResult Res = CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);

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

return Res;
4790}

4792ExprResult 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);
4798}

4800ExprResult 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 (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<void> (0))
         "should be able to convert any integer type to size type")(static_cast<void> (0));
  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);
4864}

4866void 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);
4877}

4879void 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);
}
4912}

4914ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
                                        Expr *LowerBound,
                                        SourceLocation ColonLocFirst,
                                        SourceLocation ColonLocSecond,
                                        Expr *Length, Expr *Stride,
                                        SourceLocation RBLoc) {
if (Base->getType()->isPlaceholderType() &&
    !Base->getType()->isSpecificPlaceholderType(
        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->getType()->isSpecificPlaceholderType(
        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);
5100}

5102ExprResult Sema::ActOnOMPArrayShapingExpr(Expr *Base, SourceLocation LParenLoc,
                                        SourceLocation RParenLoc,
                                        ArrayRef<Expr *> Dims,
                                        ArrayRef<SourceRange> Brackets) {
if (Base->getType()->isPlaceholderType()) {
  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->getType()->isPlaceholderType()) {
    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);
5175}

5177ExprResult 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<void> (0));
  // 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);
  }
  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;
    }
    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->isNullValue()) {
      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);
5461}

5463ExprResult
5464Sema::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 = Context.DependentTy;
} 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->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<void> (0))
       !ResultType.isCForbiddenLValueType())(static_cast<void> (0));

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

5658bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
                                ParmVarDecl *Param) {
if (Param->hasUnparsedDefaultArg()) {
  // 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() &&
    InstantiateDefaultArgument(CallLoc, FD, Param))
  return true;

assert(Param->hasInit() && "default argument but no initializer?")(static_cast<void> (0));

// 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 Init = dyn_cast<ExprWithCleanups>(Param->getInit())) {
  // Set the "needs cleanups" bit regardless of whether there are
  // any explicit objects.
  Cleanup.setExprNeedsCleanups(Init->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(!Init->getNumObjects() &&(static_cast<void> (0))
         "default argument expression has capturing blocks?")(static_cast<void> (0));
}

// We already type-checked the argument, so we know it works.
// Just mark all of the declarations in this potentially-evaluated expression
// as being "referenced".
EnterExpressionEvaluationContext EvalContext(
    *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
MarkDeclarationsReferencedInExpr(Param->getDefaultArg(),
                                 /*SkipLocalVariables=*/true);
return false;
5710}

5712ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
                                      FunctionDecl *FD, ParmVarDecl *Param) {
assert(Param->hasDefaultArg() && "can't build nonexistent default arg")(static_cast<void> (0));
if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
  return ExprError();
return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
5718}

5720Sema::VariadicCallType
5721Sema::getVariadicCallType(FunctionDecl *FDecl, const FunctionProtoType *Proto,
                        Expr *Fn) {
if (Proto && Proto->isVariadic()) {
  if (dyn_cast_or_null<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;
5737}

5739namespace {
5740class FunctionCallCCC final : public FunctionCallFilterCCC {
5741public:
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);
}

5760private:
const IdentifierInfo *const FunctionName;
5762};
5763}

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

5803/// ConvertArgumentsForCall - Converts the arguments specified in
5804/// Args/NumArgs to the parameter types of the function FDecl with
5805/// function prototype Proto. Call is the call expression itself, and
5806/// Fn is the function expression. For a C++ member function, this
5807/// routine does not attempt to convert the object argument. Returns
5808/// true if the call is ill-formed.
5809bool
5810Sema::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<void> (0))
         "We should have reserved space for the default arguments before!")(static_cast<void> (0));
}

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

5927bool 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<void> (0));

    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;
6029}

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

6040/// CheckStaticArrayArgument - If the given argument corresponds to a static
6041/// array parameter, check that it is non-null, and that if it is formed by
6042/// array-to-pointer decay, the underlying array is sufficiently large.
6043///
6044/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
6045/// array type derivation, then for each call to the function, the value of the
6046/// corresponding actual argument shall provide access to the first element of
6047/// an array with at least as many elements as specified by the size expression.
6048void
6049Sema::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;
}

Optional<CharUnits> ArgSize =
    getASTContext().getTypeSizeInCharsIfKnown(ArgCAT);
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);
}
6099}

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

6105/// Is the given type a placeholder that we need to lower out
6106/// immediately during argument processing?
6107static 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.
6114#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
6116#include "clang/Basic/OpenCLImageTypes.def"
6117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
6119#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.
6122#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
6124#include "clang/Basic/AArch64SVEACLETypes.def"
6125#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
6127#include "clang/Basic/PPCTypes.def"
6128#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6129#include "clang/Basic/RISCVVTypes.def"
6130#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6131#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6132#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")__builtin_unreachable();
6165}

6167/// Check an argument list for placeholders that we won't try to
6168/// handle later.
6169static 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;
6181}

6183/// If a builtin function has a pointer argument with no explicit address
6184/// space, then it should be able to accept a pointer to any address
6185/// space as input.  In order to do this, we need to replace the
6186/// standard builtin declaration with one that uses the same address space
6187/// as the call.
6188///
6189/// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
6190///                  it does not contain any pointer arguments without
6191///                  an address space qualifer.  Otherwise the rewritten
6192///                  FunctionDecl is returned.
6193/// TODO: Handle pointer return types.
6194static 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()) {
    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;
6265}

6267static 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;
}
6292}

6294static 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<void> (0));

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

6335static void
6336tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
  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);
}
6373}

6375ExprResult 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);

return Call;
6401}

6403/// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
6404/// This provides the location of the left/right parens and a list of comma
6405/// locations.
6406ExprResult 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, 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, 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 (isa<MemberExpr>(NakedFn))
  NDecl = cast<MemberExpr>(NakedFn)->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();

      // Only allow implicit casting from a non-default address space pointee
      // type to a default address space pointee type
      if (ArgAS != LangAS::Default || ParamAS == LangAS::Default)
        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<void> (0));
  assert((Fn->containsErrors() ||(static_cast<void> (0))
          llvm::any_of(ArgExprs,(static_cast<void> (0))
                       [](clang::Expr *E) { return E->containsErrors(); })) &&(static_cast<void> (0))
         "should only occur in error-recovery path.")(static_cast<void> (0));
  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);
6603}

6605/// BuildBuiltinCallExpr - Create a call to a builtin function specified by Id
6606//  with the specified CallArgs
6607Expr *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<void> (0));

ExprResult DeclRef =
    BuildDeclRefExpr(BuiltInDecl, BuiltInDecl->getType(), VK_LValue, Loc);
assert(DeclRef.isUsable() && "Builtin reference cannot fail")(static_cast<void> (0));

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

assert(!Call.isInvalid() && "Call to builtin cannot fail!")(static_cast<void> (0));
return Call.get();
6626}

6628/// Parse a __builtin_astype expression.
6629///
6630/// __builtin_astype( value, dst type )
6631///
6632ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                               SourceLocation BuiltinLoc,
                               SourceLocation RParenLoc) {
QualType DstTy = GetTypeFromParser(ParsedDestTy);
return BuildAsTypeExpr(E, DstTy, BuiltinLoc, RParenLoc);
6637}

6639/// Create a new AsTypeExpr node (bitcast) from the arguments.
6640ExprResult 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);
6652}

6654/// ActOnConvertVectorExpr - create a new convert-vector expression from the
6655/// provided arguments.
6656///
6657/// __builtin_convertvector( value, dst type )
6658///
6659ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
                                      SourceLocation BuiltinLoc,
                                      SourceLocation RParenLoc) {
TypeSourceInfo *TInfo;
GetTypeFromParser(ParsedDestTy, &TInfo);
return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
6665}

6667/// BuildResolvedCallExpr - Build a call to a resolved expression,
6668/// i.e. an expression not of \p OverloadTy.  The expression should
6669/// unary-convert to an expression of function-pointer or
6670/// block-pointer type.
6671///
6672/// \param NDecl the declaration being called, if available
6673ExprResult 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<void> (0))
         "CUDAKernelCallExpr should not use ADL")(static_cast<void> (0));
  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::makeArrayRef(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<void> (0));

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

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

6948ExprResult
6949Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
                         SourceLocation RParenLoc, Expr *InitExpr) {
assert(Ty && "ActOnCompoundLiteral(): missing type")(static_cast<void> (0));
assert(InitExpr && "ActOnCompoundLiteral(): missing expression")(static_cast<void> (0));

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

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

6962ExprResult
6963Sema::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()) {
    if (!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);
7072}

7074ExprResult
7075Sema::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);
7140}

7142ExprResult
7143Sema::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;
7166}

7168/// Do an explicit extend of the given block pointer if we're in ARC.
7169void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->getType()->isBlockPointerType())(static_cast<void> (0));
assert(E.get()->isPRValue())(static_cast<void> (0));

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

7182/// Prepare a conversion of the given expression to an ObjC object
7183/// pointer type.
7184CastKind 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<void> (0));
  return CK_CPointerToObjCPointerCast;
}
7195}

7197/// Prepares for a scalar cast, performing all the necessary stages
7198/// except the final cast and returning the kind required.
7199CastKind 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")__builtin_unreachable();

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")__builtin_unreachable();
  }
  llvm_unreachable("Should have returned before this")__builtin_unreachable();

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")__builtin_unreachable();
  }
  llvm_unreachable("Should have returned before this")__builtin_unreachable();

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")__builtin_unreachable();
  case Type::STK_FixedPoint:
    return CK_IntegralToFixedPoint;
  }
  llvm_unreachable("Should have returned before this")__builtin_unreachable();

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?")__builtin_unreachable();
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")__builtin_unreachable();
  case Type::STK_FixedPoint:
    return CK_FloatingToFixedPoint;
  }
  llvm_unreachable("Should have returned before this")__builtin_unreachable();

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?")__builtin_unreachable();
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")__builtin_unreachable();
  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")__builtin_unreachable();

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?")__builtin_unreachable();
  case Type::STK_MemberPointer:
    llvm_unreachable("member pointer type in C")__builtin_unreachable();
  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")__builtin_unreachable();
}

llvm_unreachable("Unhandled scalar cast")__builtin_unreachable();
7404}

7406static bool breakDownVectorType(QualType type, uint64_t &len,
                              QualType &eltType) {
// Vectors are simple.
if (const VectorType *vecType = type->getAs<VectorType>()) {
96
←
Assuming the object is a 'VectorType'→
97
←
Assuming 'vecType' is non-null→
98
←
Taking true branch→
103
←
Assuming the object is a 'VectorType'→
104
←
Assuming 'vecType' is non-null→
105
←
Taking true branch→
  len = vecType->getNumElements();
  eltType = vecType->getElementType();
  assert(eltType->isScalarType())(static_cast<void> (0));
  return true;
99
←
Returning the value 1, which participates in a condition later→
106
←
Returning the value 1, which participates in a condition later→
}

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

7425/// Are the two types SVE-bitcast-compatible types? I.e. is bitcasting from the
7426/// first SVE type (e.g. an SVE VLAT) to the second type (e.g. an SVE VLST)
7427/// allowed?
7428///
7429/// This will also return false if the two given types do not make sense from
7430/// the perspective of SVE bitcasts.
7431bool Sema::isValidSveBitcast(QualType srcTy, QualType destTy) {
assert(srcTy->isVectorType() || destTy->isVectorType())(static_cast<void> (0));

auto ValidScalableConversion = [](QualType FirstType, QualType SecondType) {
  if (!FirstType->isSizelessBuiltinType())
    return false;

  const auto *VecTy = SecondType->getAs<VectorType>();
  return VecTy &&
         VecTy->getVectorKind() == VectorType::SveFixedLengthDataVector;
};

return ValidScalableConversion(srcTy, destTy) ||
       ValidScalableConversion(destTy, srcTy);
7445}

7447/// Are the two types matrix types and do they have the same dimensions i.e.
7448/// do they have the same number of rows and the same number of columns?
7449bool 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();
7458}

7460bool Sema::areVectorTypesSameSize(QualType SrcTy, QualType DestTy) {
assert(DestTy->isVectorType() || SrcTy->isVectorType())(static_cast<void> (0));

uint64_t SrcLen, DestLen;
QualType SrcEltTy, DestEltTy;
if (!breakDownVectorType(SrcTy, SrcLen, SrcEltTy))
95
←
Calling 'breakDownVectorType'→
100
←
Returning from 'breakDownVectorType'→
101
←
Taking false branch→
  return false;
if (!breakDownVectorType(DestTy, DestLen, DestEltTy))
102
←
Calling 'breakDownVectorType'→
107
←
Returning from 'breakDownVectorType'→
108
←
Taking false branch→
  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);
109
←
Assuming the condition is true→
110
←
Returning the value 1, which participates in a condition later→
7477}

7479/// Are the two types lax-compatible vector types?  That is, given
7480/// that one of them is a vector, do they have equal storage sizes,
7481/// where the storage size is the number of elements times the element
7482/// size?
7483///
7484/// This will also return false if either of the types is neither a
7485/// vector nor a real type.
7486bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
assert(destTy->isVectorType() || srcTy->isVectorType())(static_cast<void> (0));

// 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;
92
←
Assuming the condition is false→
if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;
93
←
Assuming the condition is false→

return areVectorTypesSameSize(srcTy, destTy);
94
←
Calling 'Sema::areVectorTypesSameSize'→
111
←
Returning from 'Sema::areVectorTypesSameSize'→
112
←
Returning the value 1, which participates in a condition later→
7498}

7500/// Is this a legal conversion between two types, one of which is
7501/// known to be a vector type?
7502bool Sema::isLaxVectorConversion(QualType srcTy, QualType destTy) {
assert(destTy->isVectorType() || srcTy->isVectorType())(static_cast<void> (0));

switch (Context.getLangOpts().getLaxVectorConversions()) {
89
←
Control jumps to 'case All:'  at line 7523→
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);
90
←
 Execution continues on line 7527→
91
←
Calling 'Sema::areLaxCompatibleVectorTypes'→
113
←
Returning from 'Sema::areLaxCompatibleVectorTypes'→
114
←
Returning the value 1, which participates in a condition later→
7528}

7530bool 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;
7549}

7551bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
                         CastKind &Kind) {
assert(VectorTy->isVectorType() && "Not a vector type!")(static_cast<void> (0));

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;
7569}

7571ExprResult Sema::prepareVectorSplat(QualType VectorTy, Expr *SplattedExpr) {
QualType DestElemTy = VectorTy->castAs<VectorType>()->getElementType();

if (DestElemTy == SplattedExpr->getType())
  return SplattedExpr;

assert(DestElemTy->isFloatingType() ||(static_cast<void> (0))
       DestElemTy->isIntegralOrEnumerationType())(static_cast<void> (0));

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

7604ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
                                  Expr *CastExpr, CastKind &Kind) {
assert(DestTy->isExtVectorType() && "Not an extended vector type!")(static_cast<void> (0));

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

7638ExprResult
7639Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                  Declarator &D, ParsedType &Ty,
                  SourceLocation RParenLoc, Expr *CastExpr) {
assert(!D.isInvalidType() && (CastExpr != nullptr) &&(static_cast<void> (0))
       "ActOnCastExpr(): missing type or expr")(static_cast<void> (0));

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() &&
    !getSourceManager().isInSystemMacro(LParenLoc))
  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);
7711}

7713ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
                                  SourceLocation RParenLoc, Expr *E,
                                  TypeSourceInfo *TInfo) {
assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&(static_cast<void> (0))
       "Expected paren or paren list expression")(static_cast<void> (0));

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<void> (0));

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

7796/// This is not an AltiVec-style cast or or C++ direct-initialization, so turn
7797/// the ParenListExpr into a sequence of comma binary operators.
7798ExprResult
7799Sema::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());
7813}

7815ExprResult Sema::ActOnParenListExpr(SourceLocation L,
                                  SourceLocation R,
                                  MultiExprArg Val) {
return ParenListExpr::Create(Context, L, Val, R);
7819}

7821/// Emit a specialized diagnostic when one expression is a null pointer
7822/// constant and the other is not a pointer.  Returns true if a diagnostic is
7823/// emitted.
7824bool 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;
7860}

7862/// Return false if the condition expression is valid, true otherwise.
7863static 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;
7879}

7881/// Handle when one or both operands are void type.
7882static QualType checkConditionalVoidType(Sema &S, ExprResult &LHS,
                                       ExprResult &RHS) {
  Expr *LHSExpr = LHS.get();
  Expr *RHSExpr = RHS.get();

  if (!LHSExpr->getType()->isVoidType())
    S.Diag(RHSExpr->getBeginLoc(), diag::ext_typecheck_cond_one_void)
        << RHSExpr->getSourceRange();
  if (!RHSExpr->getType()->isVoidType())
    S.Diag(LHSExpr->getBeginLoc(), diag::ext_typecheck_cond_one_void)
        << LHSExpr->getSourceRange();
  LHS = S.ImpCastExprToType(LHS.get(), S.Context.VoidTy, CK_ToVoid);
  RHS = S.ImpCastExprToType(RHS.get(), S.Context.VoidTy, CK_ToVoid);
  return S.Context.VoidTy;
7896}

7898/// Return false if the NullExpr can be promoted to PointerTy,
7899/// true otherwise.
7900static 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;
7909}

7911/// Checks compatibility between two pointers and return the resulting
7912/// type.
7913static 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 LHSTy;
}

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

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;
8039}

8041/// Return the resulting type when the operands are both block pointers.
8042static 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);
8064}

8066/// Return the resulting type when the operands are both pointers.
8067static QualType
8068checkConditionalObjectPointersCompatibility(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);
8103}

8105/// Return false if the first expression is not an integer and the second
8106/// expression is not a pointer, true otherwise.
8107static 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;
8123}

8125/// Simple conversion between integer and floating point types.
8126///
8127/// Used when handling the OpenCL conditional operator where the
8128/// condition is a vector while the other operands are scalar.
8129///
8130/// OpenCL v1.1 s6.3.i and s6.11.6 together require that the scalar
8131/// types are either integer or floating type. Between the two
8132/// operands, the type with the higher rank is defined as the "result
8133/// type". The other operand needs to be promoted to the same type. No
8134/// other type promotion is allowed. We cannot use
8135/// UsualArithmeticConversions() for this purpose, since it always
8136/// promotes promotable types.
8137static 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);
8178}

8180/// Convert scalar operands to a vector that matches the
8181///        condition in length.
8182///
8183/// Used when handling the OpenCL conditional operator where the
8184/// condition is a vector while the other operands are scalar.
8185///
8186/// We first compute the "result type" for the scalar operands
8187/// according to OpenCL v1.1 s6.3.i. Both operands are then converted
8188/// into a vector of that type where the length matches the condition
8189/// vector type. s6.11.6 requires that the element types of the result
8190/// and the condition must have the same number of bits.
8191static QualType
8192OpenCLConvertScalarsToVectors(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<void> (0));

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

8225/// Return false if this is a valid OpenCL condition vector
8226static 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<void> (0));
QualType EleTy = CondTy->getElementType();
if (EleTy->isIntegerType()) return false;

S.Diag(QuestionLoc, diag::err_typecheck_cond_expect_nonfloat)
  << Cond->getType() << Cond->getSourceRange();
return true;
8238}

8240/// Return false if the vector condition type and the vector
8241///        result type are compatible.
8242///
8243/// OpenCL v1.1 s6.11.6 requires that both vector types have the same
8244/// number of elements, and their element types have the same number
8245/// of bits.
8246static 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<void> (0));

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;
8268}

8270/// Return the resulting type for the conditional operator in
8271///        OpenCL (aka "ternary selection operator", OpenCL v1.1
8272///        s6.3.i) when the condition is a vector type.
8273static QualType
8274OpenCLCheckVectorConditional(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()) {
  QualType VecResTy = S.CheckVectorOperands(LHS, RHS, QuestionLoc,
                                            /*isCompAssign*/false,
                                            /*AllowBothBool*/true,
                                            /*AllowBoolConversions*/false);
  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);
8303}

8305/// Return true if the Expr is block type
8306static 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;
8315}

8317/// Note that LHS is not null here, even if this is the gnu "x ?: y" extension.
8318/// In that case, LHS = cond.
8319/// C99 6.5.15
8320QualType 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<void> (0));
  assert((Cond.get()->containsErrors() || LHS.get()->containsErrors() ||(static_cast<void> (0))
          RHS.get()->containsErrors()) &&(static_cast<void> (0))
         "should only occur in error-recovery path.")(static_cast<void> (0));
  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);

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 __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 &&
    (checkBlockType(*this, LHS.get()) | 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 ExtInts of
  // different sizes, or between ExtInts and other types.
  if (ResTy.isNull() && (LHSTy->isExtIntType() || RHSTy->isExtIntType())) {
    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 LHSTy;
}

// 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 LHSTy.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()) {
  return checkConditionalVoidType(*this, LHS, RHS);
}

// 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 LHSTy;

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

8485/// FindCompositeObjCPointerType - Helper method to find composite type of
8486/// two objective-c pointer types of the two input expressions.
8487QualType 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();
8625}

8627/// SuggestParentheses - Emit a note with a fixit hint that wraps
8628/// ParenRange in parentheses.
8629static 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;
}
8642}

8644static 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.
8653}

8655/// IsArithmeticBinaryExpr - Returns true if E is an arithmetic binary
8656/// expression, either using a built-in or overloaded operator,
8657/// and sets *OpCode to the opcode and *RHSExprs to the right-hand side
8658/// expression.
8659static 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;
8700}

8702/// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
8703/// or is a logical expression such as (x==y) which has int type, but is
8704/// commonly interpreted as boolean.
8705static 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;
8720}

8722/// DiagnoseConditionalPrecedence - Emit a warning when a conditional operator
8723/// and binary operator are mixed in a way that suggests the programmer assumed
8724/// the conditional operator has higher precedence, for example:
8725/// "int x = a + someBinaryCondition ? 1 : 2".
8726static 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()));
8759}

8761/// Compute the nullability of a conditional expression.
8762static QualType computeConditionalNullability(QualType ResTy, bool IsBin,
                                            QualType LHSTy, QualType RHSTy,
                                            ASTContext &Ctx) {
if (!ResTy->isAnyPointerType())
  return ResTy;

auto GetNullability = [&Ctx](QualType Ty) {
  Optional<NullabilityKind> Kind = Ty->getNullability(Ctx);
  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(Ctx))
  ResTy = ResTy.getSingleStepDesugaredType(Ctx);

// Create a new AttributedType with the new nullability kind.
auto NewAttr = AttributedType::getNullabilityAttrKind(MergedKind);
return Ctx.getAttributedType(NewAttr, ResTy, ResTy);
8812}

8814/// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
8815/// in the case of a the GNU conditional expr extension.
8816ExprResult 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);
8917}

8919// Check if we have a conversion between incompatible cmse function pointer
8920// types, that is, a conversion between a function pointer with the
8921// cmse_nonsecure_call attribute and one without.
8922static 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;
8935}

8937// checkPointerTypesForAssignment - This is a very tricky routine (despite
8938// being closely modeled after the C99 spec:-). The odd characteristic of this
8939// routine is it effectively iqnores the qualifiers on the top level pointee.
8940// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
8941// FIXME: add a couple examples in this comment.
8942static Sema::AssignConvertType
8943checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")(static_cast<void> (0));
assert(RHSType.isCanonical() && "RHS not canonicalized!")(static_cast<void> (0));

// 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<void> (0));
  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<void> (0));
  return Sema::FunctionVoidPointer;
}

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

9080/// checkBlockPointerTypesForAssignment - This routine determines whether two
9081/// block pointer types are compatible or whether a block and normal pointer
9082/// are compatible. It is more restrict than comparing two function pointer
9083// types.
9084static Sema::AssignConvertType
9085checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType,
                                  QualType RHSType) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")(static_cast<void> (0));
assert(RHSType.isCanonical() && "RHS not canonicalized!")(static_cast<void> (0));

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;
9131}

9133/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
9134/// for assignment compatibility.
9135static Sema::AssignConvertType
9136checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType,
                                 QualType RHSType) {
assert(LHSType.isCanonical() && "LHS was not canonicalized!")(static_cast<void> (0));
assert(RHSType.isCanonical() && "RHS was not canonicalized!")(static_cast<void> (0));

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;
9167}

9169Sema::AssignConvertType
9170Sema::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);
9181}

9183/// This helper function returns true if QT is a vector type that has element
9184/// type ElementType.
9185static bool isVector(QualType QT, QualType ElementType) {
if (const VectorType *VT = QT->getAs<VectorType>())
  return VT->getElementType().getCanonicalType() == ElementType;
return false;
9189}

9191/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
9192/// has code to accommodate several GCC extensions when type checking
9193/// pointers. Here are some objectionable examples that GCC considers warnings:
9194///
9195///  int a, *pint;
9196///  short *pshort;
9197///  struct foo *pfoo;
9198///
9199///  pint = pshort; // warning: assignment from incompatible pointer type
9200///  a = pint; // warning: assignment makes integer from pointer without a cast
9201///  pint = a; // warning: assignment makes pointer from integer without a cast
9202///  pint = pfoo; // warning: assignment from incompatible pointer type
9203///
9204/// As a result, the code for dealing with pointers is more complex than the
9205/// C99 spec dictates.
9206///
9207/// Sets 'Kind' for any result kind except Incompatible.
9208Sema::AssignConvertType
9209Sema::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 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)) {
      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)) {
      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->isSizelessBuiltinType() && RHSType->isVectorType()) ||
      (LHSType->isVectorType() && RHSType->isSizelessBuiltinType()))
    if (Context.areCompatibleSveTypes(LHSType, RHSType) ||
        Context.areLaxCompatibleSveTypes(LHSType, RHSType)) {
      Kind = CK_BitCast;
      return Compatible;
    }

  return Incompatible;
}

// Diagnose attempts to convert between __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);
  }

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

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

9528/// Constructs a transparent union from an expression that is
9529/// used to initialize the transparent union.
9530static 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);
9546}

9548Sema::AssignConvertType
9549Sema::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;
9598}

9600Sema::AssignConvertType
9601Sema::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<void> (0));

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

// C99 6.5.16.1p1: the left operand is a pointer and the right is
// a null pointer constant.
if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
     LHSType->isBlockPointerType()) &&
    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;
}

// OpenCL queue_t type assignment.
if (LHSType->isQueueT() && RHS.get()->isNullPointerConstant(
                               Context, Expr::NPC_ValueDependentIsNull)) {
  RHS = ImpCastExprToType(RHS.get(), LHSType, CK_NullToPointer);
  return Compatible;
}

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

9750namespace {
9751/// The original operand to an operator, prior to the application of the usual
9752/// arithmetic conversions and converting the arguments of a builtin operator
9753/// candidate.
9754struct 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;
9770};
9771}

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

9797// Diagnose cases where a scalar was implicitly converted to a vector and
9798// diagnose the underlying types. Otherwise, diagnose the error
9799// as invalid vector logical operands for non-C++ cases.
9800QualType 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();
9822}

9824/// Try to convert a value of non-vector type to a vector type by converting
9825/// the type to the element type of the vector and then performing a splat.
9826/// If the language is OpenCL, we only use conversions that promote scalar
9827/// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
9828/// for float->int.
9829///
9830/// OpenCL V2.0 6.2.6.p2:
9831/// An error shall occur if any scalar operand type has greater rank
9832/// than the type of the vector element.
9833///
9834/// \param scalar - if non-null, actually perform the conversions
9835/// \return true if the operation fails (but without diagnosing the failure)
9836static 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;
9879}

9881/// Convert vector E to a vector with the same number of elements but different
9882/// element type.
9883static 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<void> (0));
QualType NewVecTy = 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);
9898}

9900/// Test if a (constant) integer Int can be casted to another integer type
9901/// IntTy without losing precision.
9902static 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.getMinSignedBits()
                                                : 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);
9936}

9938/// Test if a (constant) integer Int can be casted to floating point type
9939/// FloatTy without losing precision.
9940static 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;
9978}

9980/// Attempt to convert and splat Scalar into a vector whose types matches
9981/// Vector following GCC conversion rules. The rule is that implicit
9982/// conversion can occur when Scalar can be casted to match Vector's element
9983/// type without causing truncation of Scalar.
9984static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar,
                                      ExprResult *Vector) {
QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
const VectorType *VT = VectorTy->getAs<VectorType>();
44
←
Assuming the object is a 'VectorType'→
67
←
Assuming the object is a 'VectorType'→

assert(!isa<ExtVectorType>(VT) &&(static_cast<void> (0))
       "ExtVectorTypes should not be handled here!")(static_cast<void> (0));

QualType VectorEltTy = VT->getElementType();

// Reject cases where the vector element type or the scalar element type are
// not integral or floating point types.
if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
45
←
Assuming the condition is false→
46
←
Assuming the condition is false→
47
←
Taking false branch→
68
←
Assuming the condition is false→
69
←
Assuming the condition is false→
70
←
Taking false branch→
  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) &&
48
←
Assuming the condition is false→
71
←
Assuming the condition is false→
    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) &&
49
←
Assuming the condition is false→
72
←
Assuming the condition is false→
           ScalarTy->isRealFloatingType()) {
  if (S.Context.getTypeSize(VectorEltTy) == S.Context.getTypeSize(ScalarTy))
    ScalarCast = CK_FloatingToIntegral;
  else
    return true;
} else if (VectorEltTy->isRealFloatingType()) {
50
←
Assuming the condition is false→
51
←
Taking false branch→
73
←
Assuming the condition is false→
74
←
Taking false branch→
  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())
52
←
Calling 'Type::isEnumeralType'→
55
←
Returning from 'Type::isEnumeralType'→
56
←
Taking true branch→
75
←
Calling 'Type::isEnumeralType'→
78
←
Returning from 'Type::isEnumeralType'→
79
←
Taking true branch→
  return true;
57
←
Returning the value 1, which participates in a condition later→
80
←
Returning the value 1, which participates in a condition later→

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

10072QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                 SourceLocation Loc, bool IsCompAssign,
                                 bool AllowBothBool,
                                 bool AllowBoolConversions) {
if (!IsCompAssign) {
1
Assuming 'IsCompAssign' is true→
2
←
Taking false branch→
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
3
←
Assuming the condition is false→
4
←
Taking false branch→
  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>();
5
←
Assuming the object is not a 'VectorType'→
const VectorType *RHSVecType = RHSType->getAs<VectorType>();
6
←
Assuming the object is not a 'VectorType'→
7
←
'RHSVecType' initialized to a null pointer value→
assert(LHSVecType || RHSVecType)(static_cast<void> (0));

if ((LHSVecType7.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 && LHSVecType->getElementType()->isBFloat16Type()) ||
    (RHSVecType7.2
'RHSVecType' is null
2
'RHSVecType' is null
2
'RHSVecType' is null
 && RHSVecType->getElementType()->isBFloat16Type()))
  return InvalidOperands(Loc, LHS, RHS);

// AltiVec-style "vector bool op vector bool" combinations are allowed
// for some operators but not others.
if (!AllowBothBool &&
8
←
Assuming 'AllowBothBool' is true→
    LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
    RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
  return InvalidOperands(Loc, LHS, RHS);

// If the vector types are identical, return.
if (Context.hasSameType(LHSType, RHSType))
9
←
Assuming the condition is false→
  return LHSType;

// If we have compatible AltiVec and GCC vector types, use the AltiVec type.
if (LHSVecType9.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 && 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 &&
10
←
Assuming 'AllowBoolConversions' is false→
11
←
Taking false branch→
    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 vectors are invalid
// since the ambiguity can affect the ABI.
auto IsSveConversion = [](QualType FirstType, QualType SecondType) {
  const VectorType *VecType = SecondType->getAs<VectorType>();
13
←
Assuming the object is not a 'VectorType'→
18
←
Assuming the object is not a 'VectorType'→
  return FirstType->isSizelessBuiltinType() && VecType &&
14
←
Assuming the condition is false→
15
←
Returning zero, which participates in a condition later→
19
←
Assuming the condition is false→
20
←
Returning zero, which participates in a condition later→
         (VecType->getVectorKind() == VectorType::SveFixedLengthDataVector ||
          VecType->getVectorKind() ==
              VectorType::SveFixedLengthPredicateVector);
};

if (IsSveConversion(LHSType, RHSType) || IsSveConversion(RHSType, LHSType)) {
12
←
Calling 'operator()'→
16
←
Returning from 'operator()'→
17
←
Calling 'operator()'→
21
←
Returning from 'operator()'→
22
←
Taking false branch→
  Diag(Loc, diag::err_typecheck_sve_ambiguous) << LHSType << RHSType;
  return QualType();
}

// Expressions containing GNU and SVE (fixed or sizeless) vectors are invalid
// since the ambiguity can affect the ABI.
auto IsSveGnuConversion = [](QualType FirstType, QualType SecondType) {
  const VectorType *FirstVecType = FirstType->getAs<VectorType>();
24
←
Assuming the object is a 'VectorType'→
32
←
Assuming the object is a 'VectorType'→
  const VectorType *SecondVecType = SecondType->getAs<VectorType>();
25
←
Assuming the object is a 'VectorType'→
33
←
Assuming the object is a 'VectorType'→

  if (FirstVecType && SecondVecType)
26
←
Assuming 'FirstVecType' is non-null→
27
←
Assuming 'SecondVecType' is non-null→
34
←
Assuming 'FirstVecType' is non-null→
35
←
Assuming 'SecondVecType' is non-null→
    return FirstVecType->getVectorKind() == VectorType::GenericVector &&
28
←
Assuming the condition is false→
29
←
Returning zero, which participates in a condition later→
36
←
Assuming the condition is false→
37
←
Returning zero, which participates in a condition later→
           (SecondVecType->getVectorKind() ==
                VectorType::SveFixedLengthDataVector ||
            SecondVecType->getVectorKind() ==
                VectorType::SveFixedLengthPredicateVector);

  return FirstType->isSizelessBuiltinType() && SecondVecType &&
         SecondVecType->getVectorKind() == VectorType::GenericVector;
};

if (IsSveGnuConversion(LHSType, RHSType) ||
23
←
Calling 'operator()'→
30
←
Returning from 'operator()'→
39
←
Taking false branch→
    IsSveGnuConversion(RHSType, LHSType)) {
31
←
Calling 'operator()'→
38
←
Returning from 'operator()'→
  Diag(Loc, diag::err_typecheck_sve_gnu_ambiguous) << 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 (!RHSVecType39.1
'RHSVecType' is null
1
'RHSVecType' is null
1
'RHSVecType' is null
) {
40
←
Taking true branch→
  if (isa<ExtVectorType>(LHSVecType)) {
41
←
Assuming 'LHSVecType' is not a 'ExtVectorType'→
42
←
Taking false branch→
    if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
                                  LHSVecType->getElementType(), LHSType,
                                  DiagID))
      return LHSType;
  } else {
    if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
43
←
Calling 'tryGCCVectorConvertAndSplat'→
58
←
Returning from 'tryGCCVectorConvertAndSplat'→
59
←
Taking false branch→
      return LHSType;
  }
}
if (!LHSVecType59.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
) {
60
←
Taking true branch→
  if (isa<ExtVectorType>(RHSVecType)) {
61
←
Assuming 'RHSVecType' is not a 'ExtVectorType'→
    if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
                                  LHSType, RHSVecType->getElementType(),
                                  RHSType, DiagID))
      return RHSType;
  } else {
    if (LHS.get()->isLValue() ||
62
←
Calling 'Expr::isLValue'→
65
←
Returning from 'Expr::isLValue'→
        !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
66
←
Calling 'tryGCCVectorConvertAndSplat'→
81
←
Returning from 'tryGCCVectorConvertAndSplat'→
      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 = LHSVecType82.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 ? LHSType : RHSType;
82
←
Taking false branch→
83
←
'?' condition is false→
const VectorType *VT = LHSVecType83.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 ? LHSVecType : RHSVecType;
84
←
'?' condition is false→
85
←
'VT' initialized to a null pointer value→
QualType OtherType = LHSVecType85.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 ? RHSType : LHSType;
86
←
'?' condition is false→
ExprResult *OtherExpr = LHSVecType86.1
'LHSVecType' is null
1
'LHSVecType' is null
1
'LHSVecType' is null
 ? &RHS : &LHS;
87
←
'?' condition is false→
if (isLaxVectorConversion(OtherType, VecType)) {
88
←
Calling 'Sema::isLaxVectorConversion'→
115
←
Returning from 'Sema::isLaxVectorConversion'→
116
←
Taking true branch→
  // 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 (!IsCompAssign116.1
'IsCompAssign' is true
1
'IsCompAssign' is true
1
'IsCompAssign' is true
) {
    *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() ||
117
←
Calling 'Type::isExtVectorType'→
120
←
Returning from 'Type::isExtVectorType'→
121
←
Calling 'Type::isVectorType'→
124
←
Returning from 'Type::isVectorType'→
             (OtherType->isScalarType() && VT->getNumElements() == 1)) {
125
←
Assuming the condition is true→
126
←
Called C++ object pointer is null
    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();
10280}

10282// checkArithmeticNull - Detect when a NULL constant is used improperly in an
10283// expression.  These are mainly cases where the null pointer is used as an
10284// integer instead of a pointer.
10285static 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();
10319}

10321static 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;
}
10367}

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

10382QualType 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);
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;
10414}

10416QualType 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);
  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;
10439}

10441/// Diagnose invalid arithmetic on two void pointers.
10442static 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();
10449}

10451/// Diagnose invalid arithmetic on a void pointer.
10452static 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();
10458}

10460/// Diagnose invalid arithmetic on a null pointer.
10461///
10462/// If \p IsGNUIdiom is true, the operation is using the 'p = (i8*)nullptr + n'
10463/// idiom, which we recognize as a GNU extension.
10464///
10465static 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();
10473}

10475/// Diagnose invalid subraction on a null pointer.
10476///
10477static 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.Diag(Loc, diag::warn_pointer_sub_null_ptr)
    << S.getLangOpts().CPlusPlus << Pointer->getSourceRange();
10489}

10491/// Diagnose invalid arithmetic on two function pointers.
10492static void diagnoseArithmeticOnTwoFunctionPointers(Sema &S, SourceLocation Loc,
                                                  Expr *LHS, Expr *RHS) {
assert(LHS->getType()->isAnyPointerType())(static_cast<void> (0));
assert(RHS->getType()->isAnyPointerType())(static_cast<void> (0));
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();
10505}

10507/// Diagnose invalid arithmetic on a function pointer.
10508static void diagnoseArithmeticOnFunctionPointer(Sema &S, SourceLocation Loc,
                                              Expr *Pointer) {
assert(Pointer->getType()->isAnyPointerType())(static_cast<void> (0));
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();
10517}

10519/// Emit error if Operand is incomplete pointer type
10520///
10521/// \returns True if pointer has incomplete type
10522static 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<void> (0));
QualType PointeeTy = ResType->getPointeeType();
return S.RequireCompleteSizedType(
    Loc, PointeeTy,
    diag::err_typecheck_arithmetic_incomplete_or_sizeless_type,
    Operand->getSourceRange());
10534}

10536/// Check the validity of an arithmetic pointer operand.
10537///
10538/// If the operand has pointer type, this code will check for pointer types
10539/// which are invalid in arithmetic operations. These will be diagnosed
10540/// appropriately, including whether or not the use is supported as an
10541/// extension.
10542///
10543/// \returns True when the operand is valid to use (even if as an extension).
10544static 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;
10565}

10567/// Check the validity of a binary arithmetic operation w.r.t. pointer
10568/// operands.
10569///
10570/// This routine will diagnose any invalid arithmetic on pointer operands much
10571/// like \see checkArithmeticOpPointerOperand. However, it has special logic
10572/// for emitting a single diagnostic even for operations where both LHS and RHS
10573/// are (potentially problematic) pointers.
10574///
10575/// \returns True when the operand is valid to use (even if as an extension).
10576static 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;
10625}

10627/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
10628/// literal.
10629static 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);
10656}

10658/// Emit a warning when adding a char literal to a string.
10659static 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);
}
10707}

10709/// Emit error when two pointers are incompatible.
10710static void diagnosePointerIncompatibility(Sema &S, SourceLocation Loc,
                                         Expr *LHSExpr, Expr *RHSExpr) {
assert(LHSExpr->getType()->isAnyPointerType())(static_cast<void> (0));
assert(RHSExpr->getType()->isAnyPointerType())(static_cast<void> (0));
S.Diag(Loc, diag::err_typecheck_sub_ptr_compatible)
  << LHSExpr->getType() << RHSExpr->getType() << LHSExpr->getSourceRange()
  << RHSExpr->getSourceRange();
10717}

10719// C99 6.5.6
10720QualType 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);
  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<void> (0));

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 (LHSTy->isPromotableIntegerType())
      LHSTy = Context.getPromotedIntegerType(LHSTy);
  }
  *CompLHSTy = LHSTy;
}

return PExp->getType();
10821}

10823// C99 6.5.6
10824QualType 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);
  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);
10951}

10953static bool isScopedEnumerationType(QualType T) {
if (const EnumType *ET = T->getAs<EnumType>())
  return ET->getDecl()->isScoped();
return false;
10957}

10959static 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->isExtIntType())
  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();

// If LHS does not have a signed type and non-negative value
// then, the behavior is undefined before C++2a. Warn about it.
if (Left.isNegative() && !S.getLangOpts().isSignedOverflowDefined() &&
    !S.getLangOpts().CPlusPlus20) {
  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.getMinSignedBits();
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.getMinSignedBits() << LHSType
  << Left.getBitWidth() << LHS.get()->getSourceRange()
  << RHS.get()->getSourceRange();
11051}

11053/// Return the resulting type when a vector is shifted
11054///        by a scalar or vector shift amount.
11055static 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;

// 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<void> (0));
  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;
11138}

11140// C99 6.5.7
11141QualType 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);
}

// 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);
}
// Sanity-check shift operands
DiagnoseBadShiftValues(*this, LHS, RHS, Loc, Opc, LHSType);

// "The type of the result is that of the promoted left operand."
return LHSType;
11199}

11201/// Diagnose bad pointer comparisons.
11202static 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();
11209}

11211/// Returns false if the pointers are converted to a composite type,
11212/// true otherwise.
11213static 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<void> (0))
       LHSType->isMemberPointerType() || RHSType->isMemberPointerType())(static_cast<void> (0));

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;
11240}

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

11252static 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;
}
11263}

11265static 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;
11309}

11311Sema::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;
11351}

11353static 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<void> (0));
if (LiteralKind == Sema::LK_None) {
  llvm_unreachable("Unknown Objective-C object literal kind")__builtin_unreachable();
}

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, "]");
}
11400}

11402/// Warns on !x < y, !x & y where !(x < y), !(x & y) was probably intended.
11403static 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, ")");
11442}

11444// Returns true if E refers to a non-weak array.
11445static 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();
11456}

11458/// Diagnose some forms of syntactically-obvious tautological comparison.
11459static 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());
}
11584}

11586static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK) {
switch (CK) {
default: {
11589#ifndef NDEBUG1
  llvm::errs() << "unhandled cast kind: " << CastExpr::getCastKindName(CK)
               << "\n";
11592#endif
  llvm_unreachable("unhandled cast kind")__builtin_unreachable();
}
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;
}
11621}

11623static 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")__builtin_unreachable();
11664}

11666static 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<void> (0));

  // 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 (IntType->isPromotableIntegerType())
    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);

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<void> (0));

return S.CheckComparisonCategoryType(
    *CCT, Loc, Sema::ComparisonCategoryUsage::OperatorInExpression);
11746}

11748static 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<void> (0));

if (Type->isAnyComplexType() && BinaryOperator::isRelationalOp(Opc))
  return S.InvalidOperands(Loc, LHS, RHS);

// Check for comparisons of floating point operands using != and ==.
if (Type->hasFloatingRepresentation() && BinaryOperator::isEqualityOp(Opc))
  S.CheckFloatComparison(Loc, LHS.get(), RHS.get());

// The result of comparisons is 'bool' in C++, 'int' in C.
return S.Context.getLogicalOperationType();
11773}

11775void 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");
    }
}
11799}

11801// C99 6.5.8, C++ [expr.rel]
11802QualType 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);

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<void> (0));
  assert(Context.hasSameType(LHS.get()->getType(), RHS.get()->getType()))(static_cast<void> (0));

  QualType CompositeTy = LHS.get()->getType();
  assert(!CompositeTy->isReferenceType())(static_cast<void> (0));

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

if (getLangOpts().CPlusPlus) {
  // 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.
  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();
    }
  }

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

12258// Return a signed ext_vector_type that is of identical size and number of
12259// elements. For floating point vectors, return an integer type of identical
12260// size and number of elements. In the non ext_vector_type case, search from
12261// the largest type to the smallest type to avoid cases where long long == long,
12262// where long gets picked over long long.
12263QualType Sema::GetSignedVectorType(QualType V) {
const VectorType *VTy = V->castAs<VectorType>();
unsigned TypeSize = Context.getTypeSize(VTy->getElementType());

if (isa<ExtVectorType>(VTy)) {
  if (TypeSize == Context.getTypeSize(Context.CharTy))
    return Context.getExtVectorType(Context.CharTy, VTy->getNumElements());
  else if (TypeSize == Context.getTypeSize(Context.ShortTy))
    return Context.getExtVectorType(Context.ShortTy, VTy->getNumElements());
  else if (TypeSize == Context.getTypeSize(Context.IntTy))
    return Context.getExtVectorType(Context.IntTy, VTy->getNumElements());
  else if (TypeSize == Context.getTypeSize(Context.LongTy))
    return Context.getExtVectorType(Context.LongTy, VTy->getNumElements());
  assert(TypeSize == Context.getTypeSize(Context.LongLongTy) &&(static_cast<void> (0))
         "Unhandled vector element size in vector compare")(static_cast<void> (0));
  return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements());
}

if (TypeSize == Context.getTypeSize(Context.LongLongTy))
  return Context.getVectorType(Context.LongLongTy, VTy->getNumElements(),
                               VectorType::GenericVector);
else if (TypeSize == Context.getTypeSize(Context.LongTy))
  return Context.getVectorType(Context.LongTy, VTy->getNumElements(),
                               VectorType::GenericVector);
else if (TypeSize == Context.getTypeSize(Context.IntTy))
  return Context.getVectorType(Context.IntTy, VTy->getNumElements(),
                               VectorType::GenericVector);
else if (TypeSize == Context.getTypeSize(Context.ShortTy))
  return Context.getVectorType(Context.ShortTy, VTy->getNumElements(),
                               VectorType::GenericVector);
assert(TypeSize == Context.getTypeSize(Context.CharTy) &&(static_cast<void> (0))
       "Unhandled vector element size in vector compare")(static_cast<void> (0));
return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
                             VectorType::GenericVector);
12297}

12299/// CheckVectorCompareOperands - vector comparisons are a clang extension that
12300/// operates on extended vector types.  Instead of producing an IntTy result,
12301/// like a scalar comparison, a vector comparison produces a vector of integer
12302/// types.
12303QualType 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);
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 (BinaryOperator::isEqualityOp(Opc) &&
    LHSType->hasFloatingRepresentation()) {
  assert(RHS.get()->getType()->hasFloatingRepresentation())(static_cast<void> (0));
  CheckFloatComparison(Loc, LHS.get(), RHS.get());
}

// Return a signed type for the vector.
return GetSignedVectorType(vType);
12360}

12362static 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.find('\'') != StringRef::npos ||
    RHSStrRef.find('\'') != StringRef::npos)
  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;
}
12483}

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

12508QualType 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<void> (0));

if (Context.hasSameType(LHSType, RHSType))
  return LHSType;

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

12554QualType 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<void> (0));

if (LHSMatType && RHSMatType) {
  if (LHSMatType->getNumColumns() != RHSMatType->getNumRows())
    return InvalidOperands(Loc, LHS, RHS);

  if (!Context.hasSameType(LHSMatType->getElementType(),
                           RHSMatType->getElementType()))
    return InvalidOperands(Loc, LHS, RHS);

  return Context.getConstantMatrixType(LHSMatType->getElementType(),
                                       LHSMatType->getNumRows(),
                                       RHSMatType->getNumColumns());
}
return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
12583}

12585inline 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;

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

12626// C99 6.5.[13,14]
12627inline 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;
12728}

12730static 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;
12738}

12740/// Is the given expression (which must be 'const') a reference to a
12741/// variable which was originally non-const, but which has become
12742/// 'const' due to being captured within a block?
12743enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda };
12744static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
assert(E->isLValue() && E->getType().isConstQualified())(static_cast<void> (0));
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<void> (0));

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

12780static bool IsTypeModifiable(QualType Ty, bool IsDereference) {
Ty = Ty.getNonReferenceType();
if (IsDereference && Ty->isPointerType())
  Ty = Ty->getPointeeType();
return !Ty.isConstQualified();
12785}

12787// Update err_typecheck_assign_const and note_typecheck_assign_const
12788// when this enum is changed.
12789enum {
ConstFunction,
ConstVariable,
ConstMember,
ConstMethod,
NestedConstMember,
ConstUnknown,  // Keep as last element
12796};

12798/// Emit the "read-only variable not assignable" error and print notes to give
12799/// more information about why the variable is not assignable, such as pointing
12800/// to the declaration of a const variable, showing that a method is const, or
12801/// that the function is returning a const reference.
12802static 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<void> (0));
        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;
12919}

12921enum OriginalExprKind {
OEK_Variable,
OEK_Member,
OEK_LValue
12925};

12927static 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::find(RecordTypeList, FieldRecTy) == RecordTypeList.end())
        RecordTypeList.push_back(FieldRecTy);
    }
  }
  ++NextToCheckIndex;
}
12964}

12966/// Emit an error for the case where a record we are trying to assign to has a
12967/// const-qualified field somewhere in its hierarchy.
12968static void DiagnoseRecursiveConstFields(Sema &S, const Expr *E,
                                       SourceLocation Loc) {
QualType Ty = E->getType();
assert(Ty->isRecordType() && "lvalue was not record?")(static_cast<void> (0));
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);
12987}

12989/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,
12990/// emit an error and return true.  If so, return false.
12991static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
assert(!E->hasPlaceholderType(BuiltinType::PseudoObject))(static_cast<void> (0));

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

13119static 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;
}
13161}

13163// C99 6.5.16.1
13164QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
                                     SourceLocation Loc,
                                     QualType CompoundType) {
assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject))(static_cast<void> (0));

// 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);
  } else {
    // C++2a [expr.ass]p6:
    //   [Compound-assignment] expressions are deprecated if E1 has
    //   volatile-qualified type
    Diag(Loc, diag::warn_deprecated_compound_assign_volatile) << LHSType;
  }
}

// C99 6.5.16p3: The type of an assignment expression is the type of the
// left operand unless the left operand has qualified type, in which case
// it is the unqualified version of the type of the left operand.
// C99 6.5.16.1p2: In simple assignment, the value of the right operand
// is converted to the type of the assignment expression (above).
// C++ 5.17p1: the type of the assignment expression is that of its left
// operand.
return (getLangOpts().CPlusPlus
        ? LHSType : LHSType.getUnqualifiedType());
13295}

13297// Only ignore explicit casts to void.
13298static bool IgnoreCommaOperand(const Expr *E) {
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;
  }
}

return false;
13314}

13316// Look for instances where it is likely the comma operator is confused with
13317// another operator.  There is an explicit list of acceptable expressions for
13318// the left hand side of the comma operator, otherwise emit a warning.
13319void 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))
  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()),
                                  ")");
13365}

13367// C99 6.5.17
13368static 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());

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

13402/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
13403/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
13404static 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<void> (0));

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


13494/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
13495/// This routine allows us to typecheck complex/recursive expressions
13496/// where the declaration is needed for type checking. We only need to
13497/// handle cases when the expression references a function designator
13498/// or is an lvalue. Here are some examples:
13499///  - &(x) => x
13500///  - &*****f => f for f a function designator.
13501///  - &s.xx => s
13502///  - &s.zz[1].yy -> s, if zz is an array
13503///  - *(x + 1) -> x, if x is an array
13504///  - &"123"[2] -> 0
13505///  - & __real__ x -> x
13506///
13507/// FIXME: We don't recurse to the RHS of a comma, nor handle pointers to
13508/// members.
13509static 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;
}
13554}

13556namespace {
13557enum {
AO_Bit_Field = 0,
AO_Vector_Element = 1,
AO_Property_Expansion = 2,
AO_Register_Variable = 3,
AO_Matrix_Element = 4,
AO_No_Error = 5
13564};
13565}
13566/// Diagnose invalid operand for address of operations.
13567///
13568/// \param Type The type of operand which cannot have its address taken.
13569static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
                                       Expr *E, unsigned Type) {
S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
13572}

13574/// CheckAddressOfOperand - The operand of & must be either a function
13575/// designator or an lvalue designating an object. If it is an lvalue, the
13576/// object cannot be declared with storage class register or be a bit field.
13577/// Note: The usual conversions are *not* applied to the operand of the &
13578/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
13579/// In C++, the operand might be an overloaded function name, in which case
13580/// we allow the '&' but retain the overloaded-function type.
13581QualType 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<void> (0));
      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()->getType()->isPlaceholderType())(static_cast<void> (0));

// 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>(dcl) && !isa<NonTypeTemplateParmDecl>(dcl) &&
             !isa<BindingDecl>(dcl) && !isa<MSGuidDecl>(dcl))
    llvm_unreachable("Unknown/unexpected decl type")__builtin_unreachable();
}

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

CheckAddressOfPackedMember(op);

return Context.getPointerType(op->getType());
13798}

13800static 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())
  if (!FD->ModifiedNonNullParams.count(Param))
    FD->ModifiedNonNullParams.insert(Param);
13816}

13818/// CheckIndirectionOperand - Type check unary indirection (prefix '*').
13819static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
                                      SourceLocation OpLoc) {
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();
}

// Note that per both C89 and C99, indirection is always legal, even if Result
// is an incomplete type or void.  It would be possible to warn about
// dereferencing a void pointer, but it's completely well-defined, and such a
// warning is unlikely to catch any mistakes. In C++, indirection is not valid
// for pointers to 'void' but is fine for any other pointer type:
//
// 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
if (S.getLangOpts().CPlusPlus && Result->isVoidType())
  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;
13878}

13880BinaryOperatorKind Sema::ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind) {
BinaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown binop!")__builtin_unreachable();
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;
13919}

13921static inline UnaryOperatorKind ConvertTokenKindToUnaryOpcode(
tok::TokenKind Kind) {
UnaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown unary op!")__builtin_unreachable();
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;
13939}

13941/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
13942/// This warning suppressed in the event of macro expansions.
13943static 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;

S.Diag(OpLoc, IsBuiltin ? diag::warn_self_assignment_builtin
                        : diag::warn_self_assignment_overloaded)
    << LHSDeclRef->getType() << LHSExpr->getSourceRange()
    << RHSExpr->getSourceRange();
13975}

13977/// Check if a bitwise-& is performed on an Objective-C pointer.  This
13978/// is usually indicative of introspection within the Objective-C pointer.
13979static 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();
}
14018}

14020static 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;
14030}

14032// This helper function promotes a binary operator's operands (which are of a
14033// half vector type) to a vector of floats and then truncates the result to
14034// a vector of either half or short.
14035static 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<void> (0))
        isVector(ResultTy, Context.ShortTy)) &&(static_cast<void> (0))
       "Result must be a vector of half or short")(static_cast<void> (0));
assert(isVector(LHS.get()->getType(), Context.HalfTy) &&(static_cast<void> (0))
       isVector(RHS.get()->getType(), Context.HalfTy) &&(static_cast<void> (0))
       "both operands expected to be a half vector")(static_cast<void> (0));

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

14067static std::pair<ExprResult, ExprResult>
14068CorrectDelayedTyposInBinOp(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);
14087}

14089/// Returns true if conversion between vectors of halfs and vectors of floats
14090/// is needed.
14091static 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));
14113}

14115/// CreateBuiltinBinOp - Creates a new built-in binary operation with
14116/// operator @p Opc at location @c TokLoc. This routine only supports
14117/// built-in operations; ActOnBinOp handles overloaded operators.
14118ExprResult 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();
  }
}

switch (Opc) {
case BO_Assign:
  ResultTy = CheckAssignmentOperands(LHS.get(), RHS, OpLoc, QualType());
  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<void> (0));
  break;
case BO_And:
  checkObjCPointerIntrospection(*this, LHS, RHS, OpLoc);
  LLVM_FALLTHROUGH[[gnu::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);
  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);
  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);
  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);
  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);
  break;
case BO_AndAssign:
case BO_OrAssign: // fallthrough
  DiagnoseSelfAssignment(*this, LHS.get(), RHS.get(), OpLoc, true);
  LLVM_FALLTHROUGH[[gnu::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);
  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<void> (0))
    (Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) ==(static_cast<void> (0))
                            isVector(LHS.get()->getType(), Context.HalfTy)) &&(static_cast<void> (0))
    "both sides are half vectors or neither sides are")(static_cast<void> (0));
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);
14388}

14390/// DiagnoseBitwisePrecedence - Emit a warning when bitwise and comparison
14391/// operators are mixed in a way that suggests that the programmer forgot that
14392/// comparison operators have higher precedence. The most typical example of
14393/// such code is "flags & 0x0020 != 0", which is equivalent to "flags & 1".
14394static 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);
14431}

14433/// It accepts a '&&' expr that is inside a '||' one.
14434/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
14435/// in parentheses.
14436static void
14437EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
                                     BinaryOperator *Bop) {
assert(Bop->getOpcode() == BO_LAnd)(static_cast<void> (0));
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());
14446}

14448/// Returns true if the given expression can be evaluated as a constant
14449/// 'true'.
14450static bool EvaluatesAsTrue(Sema &S, Expr *E) {
bool Res;
return !E->isValueDependent() &&
       E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && Res;
14454}

14456/// Returns true if the given expression can be evaluated as a constant
14457/// 'false'.
14458static bool EvaluatesAsFalse(Sema &S, Expr *E) {
bool Res;
return !E->isValueDependent() &&
       E->EvaluateAsBooleanCondition(Res, S.getASTContext()) && !Res;
14462}

14464/// Look for '&&' in the left hand of a '||' expr.
14465static 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 "a && b || 0" don't warn since the precedence doesn't matter.
    if (EvaluatesAsFalse(S, RHSExpr))
      return;
    // If it's "1 && a || b" don't warn since the precedence doesn't matter.
    if (!EvaluatesAsTrue(S, Bop->getLHS()))
      return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
  } else if (Bop->getOpcode() == BO_LOr) {
    if (BinaryOperator *RBop = dyn_cast<BinaryOperator>(Bop->getRHS())) {
      // If it's "a || b && 1 || c" we didn't warn earlier for
      // "a || b && 1", but warn now.
      if (RBop->getOpcode() == BO_LAnd && EvaluatesAsTrue(S, RBop->getRHS()))
        return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, RBop);
    }
  }
}
14484}

14486/// Look for '&&' in the right hand of a '||' expr.
14487static 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 "0 || a && b" don't warn since the precedence doesn't matter.
    if (EvaluatesAsFalse(S, LHSExpr))
      return;
    // If it's "a || b && 1" don't warn since the precedence doesn't matter.
    if (!EvaluatesAsTrue(S, Bop->getRHS()))
      return EmitDiagnosticForLogicalAndInLogicalOr(S, OpLoc, Bop);
  }
}
14499}

14501/// Look for bitwise op in the left or right hand of a bitwise op with
14502/// lower precedence and emit a diagnostic together with a fixit hint that wraps
14503/// the '&' expression in parentheses.
14504static 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());
  }
}
14517}

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

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

14559/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
14560/// precedence.
14561static 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);
14593}

14595// Binary Operators.  'Tok' is the token for the operator.
14596ExprResult 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<void> (0));
assert(RHSExpr && "ActOnBinOp(): missing right expression")(static_cast<void> (0));

// Emit warnings for tricky precedence issues, e.g. "bitfield & 0x4 == 0"
DiagnoseBinOpPrecedence(*this, Opc, TokLoc, LHSExpr, RHSExpr);

return BuildBinOp(S, TokLoc, Opc, LHSExpr, RHSExpr);
14607}

14609void 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);
}
14620}

14622/// Build an overloaded binary operator expression in the given scope.
14623static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
                                     BinaryOperatorKind Opc,
                                     Expr *LHS, Expr *RHS) {
switch (Opc) {
case BO_Assign:
case BO_DivAssign:
case BO_RemAssign:
case BO_SubAssign:
case BO_AndAssign:
case BO_OrAssign:
case BO_XorAssign:
  DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
  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);
14648}

14650ExprResult 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() &&
        std::any_of(OE->decls_begin(), OE->decls_end(), [](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<void> (0));
  assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&(static_cast<void> (0))
         "Should only occur in error-recovery path.")(static_cast<void> (0));
  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);
14795}

14797static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
if (T.isNull() || T->isDependentType())
  return false;

if (!T->isPromotableIntegerType())
  return true;

return Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy);
14805}

14807ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
                                    UnaryOperatorKind Opc,
                                    Expr *InputExpr) {
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());
  }
}

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);
  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 (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<void> (0))
                 "the co_await expression must be non-dependant before "(static_cast<void> (0))
                 "building operator co_await")(static_cast<void> (0));
  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;
15027}

15029/// Determine whether the given expression is a qualified member
15030/// access expression, of a form that could be turned into a pointer to member
15031/// with the address-of operator.
15032bool 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;
15067}

15069ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
                            UnaryOperatorKind Opc, Expr *Input) {
// 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);
15110}

15112// Unary Operators.  'Tok' is the token for the operator.
15113ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
                            tok::TokenKind Op, Expr *Input) {
return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
15116}

15118/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
15119ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
                              LabelDecl *TheDecl) {
TheDecl->markUsed(Context);
// Create the AST node.  The address of a label always has type 'void*'.
return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
                                   Context.getPointerType(Context.VoidTy));
15125}

15127void Sema::ActOnStartStmtExpr() {
PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
15129}

15131void Sema::ActOnStmtExprError() {
// Note that function is also called by TreeTransform when leaving a
// StmtExpr scope without rebuilding anything.

DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();
15137}

15139ExprResult Sema::ActOnStmtExpr(Scope *S, SourceLocation LPLoc, Stmt *SubStmt,
                             SourceLocation RPLoc) {
return BuildStmtExpr(LPLoc, SubStmt, RPLoc, getTemplateDepth(S));
15142}

15144ExprResult Sema::BuildStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
                             SourceLocation RPLoc, unsigned TemplateDepth) {
assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!")(static_cast<void> (0));
CompoundStmt *Compound = cast<CompoundStmt>(SubStmt);

if (hasAnyUnrecoverableErrorsInThisFunction())
  DiscardCleanupsInEvaluationContext();
assert(!Cleanup.exprNeedsCleanups() &&(static_cast<void> (0))
       "cleanups within StmtExpr not correctly bound!")(static_cast<void> (0));
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;
15181}

15183ExprResult 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);
15212}

15214ExprResult 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<void> (0));
      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);
15375}

15377ExprResult 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);
15393}


15396ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
                               Expr *CondExpr,
                               Expr *LHSExpr, Expr *RHSExpr,
                               SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)")(static_cast<void> (0));

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

15430//===----------------------------------------------------------------------===//
15431// Clang Extensions.
15432//===----------------------------------------------------------------------===//

15434/// ActOnBlockStart - This callback is invoked when a block literal is started.
15435void 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);
15462}

15464void Sema::ActOnBlockArguments(SourceLocation CaretLoc, Declarator &ParamInfo,
                             Scope *CurScope) {
assert(ParamInfo.getIdentifier() == nullptr &&(static_cast<void> (0))
       "block-id should have no identifier!")(static_cast<void> (0));
assert(ParamInfo.getContext() == DeclaratorContext::BlockLiteral)(static_cast<void> (0));
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, None, 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<void> (0))
       "GetTypeForDeclarator made a non-function block signature")(static_cast<void> (0));

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

15580/// ActOnBlockError - If there is an error parsing a block, this callback
15581/// is invoked to pop the information about the block from the action impl.
15582void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) {
// Leave the expression-evaluation context.
DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();

// Pop off CurBlock, handle nested blocks.
PopDeclContext();
PopFunctionScopeInfo();
15590}

15592/// ActOnBlockStmtExpr - This is called when the body of a block statement
15593/// literal was successfully completed.  ^(int x){...}
15594ExprResult 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<void> (0))
       "cleanups within block not correctly bound!")(static_cast<void> (0));
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, None, 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, None, 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;

  VarDecl *Var = 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(), false),
            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;
15777}

15779ExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
                          SourceLocation RPLoc) {
TypeSourceInfo *TInfo;
GetTypeFromParser(Ty, &TInfo);
return BuildVAArgExpr(BuiltinLoc, E, TInfo, RPLoc);
15784}

15786ExprResult 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 (TInfo->getType()->isPromotableIntegerType()) {
    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() &&
        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);
15936}

15938ExprResult 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(0);
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!")__builtin_unreachable();
}

return new (Context) GNUNullExpr(Ty, TokenLoc);
15954}

15956ExprResult Sema::ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                  SourceLocation BuiltinLoc,
                                  SourceLocation RPLoc) {
return BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, CurContext);
15960}

15962ExprResult Sema::BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                  SourceLocation BuiltinLoc,
                                  SourceLocation RPLoc,
                                  DeclContext *ParentContext) {
return new (Context)
    SourceLocExpr(Context, Kind, BuiltinLoc, RPLoc, ParentContext);
15968}

15970bool 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->isAscii())
    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;
16023}

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

16044bool 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 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!")__builtin_unreachable();
  // 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);
if (Action == AA_Passing_CFAudited)
  FDiag << FirstType << SecondType << AA_Passing << SrcExpr->getSourceRange();
else
  FDiag << FirstType << SecondType << Action << 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;
16319}

16321ExprResult 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);
16337}

16339ExprResult 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);
16356}

16358Sema::SemaDiagnosticBuilder
16359Sema::VerifyICEDiagnoser::diagnoseNotICEType(Sema &S, SourceLocation Loc,
                                           QualType T) {
return diagnoseNotICE(S, Loc);
16362}

16364Sema::SemaDiagnosticBuilder
16365Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc) {
return S.Diag(Loc, diag::ext_expr_not_ice) << S.LangOpts.CPlusPlus;
16367}

16369ExprResult
16370Sema::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")__builtin_unreachable();
    }
  } 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;
16508}

16510namespace {
// 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);
  }
};
16556}

16558ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
assert(isUnevaluatedContext() &&(static_cast<void> (0))
       "Should only transform unevaluated expressions")(static_cast<void> (0));
ExprEvalContexts.back().Context =
    ExprEvalContexts[ExprEvalContexts.size()-2].Context;
if (isUnevaluatedContext())
  return E;
return TransformToPE(*this).TransformExpr(E);
16566}

16568void
16569Sema::PushExpressionEvaluationContext(
  ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
  ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
                              LambdaContextDecl, ExprContext);
Cleanup.reset();
if (!MaybeODRUseExprs.empty())
  std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
16577}

16579void
16580Sema::PushExpressionEvaluationContext(
  ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
  ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
PushExpressionEvaluationContext(NewContext, ClosureContextDecl, ExprContext);
16585}

16587namespace {

16589const 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;
16612}

16614} // namespace

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

16632/// Check whether E, which is either a discarded-value expression or an
16633/// unevaluated operand, is a simple-assignment to a volatlie-qualified lvalue,
16634/// and if so, remove it from the list of volatile-qualified assignments that
16635/// we are going to warn are deprecated.
16636void 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;
    LHSs.erase(std::remove(LHSs.begin(), LHSs.end(), BO->getLHS()),
               LHSs.end());
  }
}
16650}

16652ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
if (isUnevaluatedContext() || !E.isUsable() || !Decl ||
    !Decl->isConsteval() || isConstantEvaluated() ||
    RebuildingImmediateInvocation)
  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);
ExprEvalContexts.back().ImmediateInvocationCandidates.emplace_back(Res, 0);
return Res;
16676}

16678static 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()) {
  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")__builtin_unreachable();
  assert(FD->isConsteval())(static_cast<void> (0));
  SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
  for (auto &Note : Notes)
    SemaRef.Diag(Note.first, Note.second);
  return;
}
CE->MoveIntoResult(Eval.Val, SemaRef.getASTContext());
16704}

16706static 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;
                           });
    assert(It != IISet.rend() &&(static_cast<void> (0))
           "ConstantExpr marked IsImmediateInvocation should "(static_cast<void> (0))
           "be present")(static_cast<void> (0));
    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()));
    return Base::TransformCXXOperatorCallExpr(E);
  }
  /// 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;
  }
  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());
assert(Res.isUsable())(static_cast<void> (0));
Res = SemaRef.MaybeCreateExprWithCleanups(Res);
It->getPointer()->setSubExpr(Res.get());
16782}

16784static void
16785HandleImmediateInvocations(Sema &SemaRef,
                         Sema::ExpressionEvaluationContextRecord &Rec) {
if ((Rec.ImmediateInvocationCandidates.size() == 0 &&
     Rec.ReferenceToConsteval.size() == 0) ||
    SemaRef.RebuildingImmediateInvocation)
  return;

/// When we have more then 1 ImmediateInvocationCandidates we need to check
/// for nested ImmediateInvocationCandidates. when we have only 1 we only
/// need to remove ReferenceToConsteval in the immediate invocation.
if (Rec.ImmediateInvocationCandidates.size() > 1) {

  /// Prevent sema calls during the tree transform from adding pointers that
  /// are already in the sets.
  llvm::SaveAndRestore<bool> 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) {
  auto *FD = cast<FunctionDecl>(DR->getDecl());
  SemaRef.Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
      << FD;
  SemaRef.Diag(FD->getLocation(), diag::note_declared_at);
}
16831}

16833void 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.")__builtin_unreachable();

    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;
16899}

16901void Sema::DiscardCleanupsInEvaluationContext() {
ExprCleanupObjects.erase(
       ExprCleanupObjects.begin() + ExprEvalContexts.back().NumCleanupObjects,
       ExprCleanupObjects.end());
Cleanup.reset();
MaybeODRUseExprs.clear();
16907}

16909ExprResult 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);
16917}

16919/// Are we in a context that is potentially constant evaluated per C++20
16920/// [expr.const]p12?
16921static 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:
    // -- 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")__builtin_unreachable();
16946}

16948/// Return true if this function has a calling convention that requires mangling
16949/// in the size of the parameter pack.
16950static 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;
16974}

16976/// Require that all of the parameter types of function be complete. Normally,
16977/// parameter types are only required to be complete when a function is called
16978/// or defined, but to mangle functions with certain calling conventions, the
16979/// mangler needs to know the size of the parameter list. In this situation,
16980/// MSVC doesn't emit an error or instantiate templates. Instead, MSVC mangles
16981/// the function as _foo@0, i.e. zero bytes of parameters, which will usually
16982/// result in a linker error. Clang doesn't implement this behavior, and instead
16983/// attempts to error at compile time.
16984static 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")__builtin_unreachable();
    }

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

17022namespace {
17023enum 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
17033};
17034}

17036/// Are we within a context in which references to resolved functions or to
17037/// variables result in odr-use?
17038static 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::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;
17067}

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

17079/// Mark a function referenced, and check whether it is odr-used
17080/// (C++ [basic.def.odr]p2, C99 6.9p3)
17081void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
                                bool MightBeOdrUse) {
assert(Func && "No function?")(static_cast<void> (0));

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()))
  checkSpecializationVisibility(Loc, Func);

if (getLangOpts().CUDA)
  CheckCUDACall(Loc, Func);

if (getLangOpts().SYCLIsDevice)
  checkSYCLDeviceFunction(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);
      }
    }
  });
}

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

17322/// Directly mark a variable odr-used. Given a choice, prefer to use
17323/// MarkVariableReferenced since it does additional checks and then
17324/// calls MarkVarDeclODRUsed.
17325/// If the variable must be captured:
17326///  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
17327///  - else capture it in the DeclContext that maps to the
17328///    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
17329static void
17330MarkVarDeclODRUsed(VarDecl *Var, 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.
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(Var);
SemaRef.tryCaptureVariable(Var, Loc, Sema::TryCapture_Implicit,
  /*EllipsisLoc*/ SourceLocation(),
  /*BuildAndDiagnose*/ true,
  CaptureType, DeclRefType,
  FunctionScopeIndexToStopAt);

if (SemaRef.LangOpts.CUDA && Var && 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) &&
             !Var->hasExternalStorage()) {
    // 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.
    SemaRef.getASTContext().CUDADeviceVarODRUsedByHost.insert(Var);
  }
}

Var->markUsed(SemaRef.Context);
17388}

17390void Sema::MarkCaptureUsedInEnclosingContext(VarDecl *Capture,
                                           SourceLocation Loc,
                                           unsigned CapturingScopeIndex) {
MarkVarDeclODRUsed(Capture, Loc, *this, &CapturingScopeIndex);
17394}

17396static void
17397diagnoseUncapturableValueReference(Sema &S, SourceLocation loc,
                                 ValueDecl *var, DeclContext *DC) {
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.
17436}


17439static bool isVariableAlreadyCapturedInScopeInfo(CapturingScopeInfo *CSI, VarDecl *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;
17466}

17468// Only block literals, captured statements, and lambda expressions can
17469// capture; other scopes don't work.
17470static DeclContext *getParentOfCapturingContextOrNull(DeclContext *DC, VarDecl *Var,
                               SourceLocation Loc,
                               const bool Diagnose, Sema &S) {
if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC) || isLambdaCallOperator(DC))
  return getLambdaAwareParentOfDeclContext(DC);
else if (Var->hasLocalStorage()) {
  if (Diagnose)
     diagnoseUncapturableValueReference(S, Loc, Var, DC);
}
return nullptr;
17480}

17482// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
17483// certain types of variables (unnamed, variably modified types etc.)
17484// so check for eligibility.
17485static bool isVariableCapturable(CapturingScopeInfo *CSI, VarDecl *Var,
                               SourceLocation Loc,
                               const bool Diagnose, Sema &S) {

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

return true;
17545}

17547// Returns true if the capture by block was successful.
17548static bool captureInBlock(BlockScopeInfo *BSI, VarDecl *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;
17616}


17619/// Capture the given variable in the captured region.
17620static bool captureInCapturedRegion(
  CapturedRegionScopeInfo *RSI, VarDecl *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;
17657}

17659/// Capture the given variable in the lambda.
17660static bool captureInLambda(LambdaScopeInfo *LSI,
                          VarDecl *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);
}

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

17759static bool canCaptureVariableByCopy(VarDecl *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;
17778}

17780/// Create up to 4 fix-its for explicit reference and value capture of \p Var or
17781/// default capture. Fixes may be omitted if they aren't allowed by the
17782/// standard, for example we can't emit a default copy capture fix-it if we
17783/// already explicitly copy capture capture another variable.
17784static void buildLambdaCaptureFixit(Sema &Sema, LambdaScopeInfo *LSI,
                                  VarDecl *Var) {
assert(LSI->ImpCaptureStyle == CapturingScopeInfo::ImpCap_None)(static_cast<void> (0));
// 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);
}
17858}

17860bool Sema::tryCaptureVariable(
  VarDecl *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();
if (Var->isInitCapture())
  VarDC = VarDC->getParent();

DeclContext *DC = CurContext;
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;
  }
}


// If the variable is declared in the current context, there is no need to
// capture it.
if (VarDC == DC) return true;

// Capture global variables if it is required to use private copy of this
// variable.
bool IsGlobal = !Var->hasLocalStorage();
if (IsGlobal &&
    !(LangOpts.OpenMP && isOpenMPCapturedDecl(Var, /*CheckScopeInfo=*/true,
                                              MaxFunctionScopesIndex)))
  return true;
Var = 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 {
  // Only block literals, captured statements, and lambda expressions can
  // capture; other scopes don't work.
  DeclContext *ParentDC = 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
        diagnoseUncapturableValueReference(*this, ExprLoc, Var, DC);
    }
    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<void> (0))
                   "Wrong number of captured regions associated with the "(static_cast<void> (0))
                   "OpenMP construct.")(static_cast<void> (0));
            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;
  }

  FunctionScopesIndex--;
  DC = ParentDC;
  Explicit = false;
} 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;
18097}

18099bool Sema::tryCaptureVariable(VarDecl *Var, SourceLocation Loc,
                            TryCaptureKind Kind, SourceLocation EllipsisLoc) {
QualType CaptureType;
QualType DeclRefType;
return tryCaptureVariable(Var, Loc, Kind, EllipsisLoc,
                          /*BuildAndDiagnose=*/true, CaptureType,
                          DeclRefType, nullptr);
18106}

18108bool Sema::NeedToCaptureVariable(VarDecl *Var, SourceLocation Loc) {
QualType CaptureType;
QualType DeclRefType;
return !tryCaptureVariable(Var, Loc, TryCapture_Implicit, SourceLocation(),
                           /*BuildAndDiagnose=*/false, CaptureType,
                           DeclRefType, nullptr);
18114}

18116QualType Sema::getCapturedDeclRefType(VarDecl *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;
18127}

18129namespace {
18130// Helper to copy the template arguments from a DeclRefExpr or MemberExpr.
18131// The produced TemplateArgumentListInfo* points to data stored within this
18132// object, so should only be used in contexts where the pointer will not be
18133// used after the CopiedTemplateArgs object is destroyed.
18134class CopiedTemplateArgs {
bool HasArgs;
TemplateArgumentListInfo TemplateArgStorage;
18137public:
template<typename RefExpr>
CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
  if (HasArgs)
    E->copyTemplateArgumentsInto(TemplateArgStorage);
}
operator TemplateArgumentListInfo*()
18144#ifdef __has_cpp_attribute
18145#if0 __has_cpp_attribute(clang::lifetimebound)1
[[clang::lifetimebound]]
18147#endif
18148#endif
{
  return HasArgs ? &TemplateArgStorage : nullptr;
}
18152};
18153}

18155/// Walk the set of potential results of an expression and mark them all as
18156/// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
18157///
18158/// \return A new expression if we found any potential results, ExprEmpty() if
18159///         not, and ExprError() if we diagnosed an error.
18160static 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")__builtin_unreachable();

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

18477ExprResult 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;
18498}

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

18513void 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")__builtin_unreachable();
  }
}

assert(MaybeODRUseExprs.empty() &&(static_cast<void> (0))
       "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?")(static_cast<void> (0));
18536}

18538static 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<void> (0))
        isa<FunctionParmPackExpr>(E)) &&(static_cast<void> (0))
       "Invalid Expr argument to DoMarkVarDeclReferenced")(static_cast<void> (0));
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<void> (0))
       "Can't instantiate a partial template specialization.")(static_cast<void> (0));

// 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 ||
               isa<VarTemplateSpecializationDecl>(Var)) {
      // 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.
      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:
  assert((!E || isa<FunctionParmPackExpr>(E)) &&(static_cast<void> (0))
         "missing non-odr-use marking for unevaluated decl ref")(static_cast<void> (0));
  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)?
  const bool RefersToEnclosingScope =
      (SemaRef.CurContext != Var->getDeclContext() &&
       Var->getDeclContext()->isFunctionOrMethod() && Var->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<void> (0));
      if (!Var->getType()->isReferenceType() ||
          !Var->isUsableInConstantExpressions(SemaRef.Context))
        LSI->addPotentialCapture(E->IgnoreParens());
    }
  }
  break;
}
18710}

18712/// Mark a variable referenced, and check whether it is odr-used
18713/// (C++ [basic.def.odr]p2, C99 6.9p3).  Note that this should not be
18714/// used directly for normal expressions referring to VarDecl.
18715void Sema::MarkVariableReferenced(SourceLocation Loc, VarDecl *Var) {
DoMarkVarDeclReferenced(*this, Loc, Var, nullptr, RefsMinusAssignments);
18717}

18719static void
18720MarkExprReferenced(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;
}

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

18755/// Perform reference-marking and odr-use handling for a DeclRefExpr.
18756///
18757/// Note, this may change the dependence of the DeclRefExpr, and so needs to be
18758/// handled with care if the DeclRefExpr is not newly-created.
18759void 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() &&
      FD->isConsteval() && !RebuildingImmediateInvocation)
    ExprEvalContexts.back().ReferenceToConsteval.insert(E);
MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
                   RefsMinusAssignments);
18775}

18777/// Perform reference-marking and odr-use handling for a MemberExpr.
18778void 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);
18795}

18797/// Perform reference-marking and odr-use handling for a FunctionParmPackExpr.
18798void Sema::MarkFunctionParmPackReferenced(FunctionParmPackExpr *E) {
for (VarDecl *VD : *E)
  MarkExprReferenced(*this, E->getParameterPackLocation(), VD, E, true,
                     RefsMinusAssignments);
18802}

18804/// Perform marking for a reference to an arbitrary declaration.  It
18805/// marks the declaration referenced, and performs odr-use checking for
18806/// functions and variables. This method should not be used when building a
18807/// normal expression which refers to a variable.
18808void 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();
18821}

18823namespace {
// 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);
};
18842}

18844bool 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);
18859}

18861void Sema::MarkDeclarationsReferencedInType(SourceLocation Loc, QualType T) {
MarkReferencedDecls Marker(*this, Loc);
Marker.TraverseType(T);
18864}

18866namespace {
18867/// Helper class that marks all of the declarations referenced by
18868/// potentially-evaluated subexpressions as "referenced".
18869class EvaluatedExprMarker : public UsedDeclVisitor<EvaluatedExprMarker> {
18870public:
typedef UsedDeclVisitor<EvaluatedExprMarker> Inherited;
bool SkipLocalVariables;

EvaluatedExprMarker(Sema &S, bool SkipLocalVariables)
    : Inherited(S), SkipLocalVariables(SkipLocalVariables) {}

void visitUsedDecl(SourceLocation Loc, Decl *D) {
  S.MarkFunctionReferenced(Loc, cast<FunctionDecl>(D));
}

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());
}
18899};
18900} // namespace

18902/// Mark any declarations that appear within this expression or any
18903/// potentially-evaluated subexpressions as "referenced".
18904///
18905/// \param SkipLocalVariables If true, don't mark local variables as
18906/// 'referenced'.
18907void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
                                          bool SkipLocalVariables) {
EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
18910}

18912/// Emit a diagnostic that describes an effect on the run-time behavior
18913/// of the program being compiled.
18914///
18915/// This routine emits the given diagnostic when the code currently being
18916/// type-checked is "potentially evaluated", meaning that there is a
18917/// possibility that the code will actually be executable. Code in sizeof()
18918/// expressions, code used only during overload resolution, etc., are not
18919/// potentially evaluated. This routine will suppress such diagnostics or,
18920/// in the absolutely nutty case of potentially potentially evaluated
18921/// expressions (C++ typeid), queue the diagnostic to potentially emit it
18922/// later.
18923///
18924/// This routine should be used for all diagnostics that describe the run-time
18925/// behavior of a program, such as passing a non-POD value through an ellipsis.
18926/// Failure to do so will likely result in spurious diagnostics or failures
18927/// during overload resolution or within sizeof/alignof/typeof/typeid.
18928bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
                             const PartialDiagnostic &PD) {
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:
  // Relevant diagnostics should be produced by constant evaluation.
  break;

case ExpressionEvaluationContext::PotentiallyEvaluated:
case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
  if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
    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()))
      break;
    // 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;
}

return false;
18969}

18971bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
                             const PartialDiagnostic &PD) {
return DiagRuntimeBehavior(
    Loc, Statement ? llvm::makeArrayRef(Statement) : llvm::None, PD);
18975}

18977bool 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;
19016}

19018// Diagnose the s/=/==/ and s/\|=/!=/ typos. Note that adding parentheses
19019// will prevent this condition from triggering, which is what we want.
19020void 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, "==");
19074}

19076/// Redundant parentheses over an equality comparison can indicate
19077/// that the user intended an assignment used as condition.
19078void 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, "=");
  }
19103}

19105ExprResult 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;
19134}

19136Sema::ConditionResult Sema::ActOnCondition(Scope *S, SourceLocation Loc,
                                         Expr *SubExpr, ConditionKind CK) {
// Empty conditions are valid in for-statements.
if (!SubExpr)
  return ConditionResult();

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

19171namespace {
/// 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!")__builtin_unreachable();
  }

  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<void> (0));
    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<void> (0));
    assert(E->getObjectKind() == OK_Ordinary)(static_cast<void> (0));
    return E;
  }

  ExprResult resolveDecl(Expr *E, ValueDecl *VD) {
    if (!isa<FunctionDecl>(VD)) return VisitExpr(E);

    E->setType(VD->getType());

    assert(E->isPRValue())(static_cast<void> (0));
    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());
  }
};
19247}

19249/// Given a function expression of unknown-any type, try to rebuild it
19250/// to have a function type.
19251static ExprResult rebuildUnknownAnyFunction(Sema &S, Expr *FunctionExpr) {
ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
if (Result.isInvalid()) return ExprError();
return S.DefaultFunctionArrayConversion(Result.get());
19255}

19257namespace {
/// 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!")__builtin_unreachable();
  }

  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<void> (0));
    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<void> (0));
    assert(E->getObjectKind() == OK_Ordinary)(static_cast<void> (0));
    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());
  }
};
19345}

19347/// Rebuilds a call expression which yielded __unknown_anytype.
19348ExprResult 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<void> (0));
  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<void> (0));

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

19450ExprResult 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<void> (0));
  Method->setReturnType(DestType);
}

// Change the type of the message.
E->setType(DestType.getNonReferenceType());
E->setValueKind(Expr::getValueKindForType(DestType));

return S.MaybeBindToTemporary(E);
19469}

19471ExprResult 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<void> (0));
  assert(E->getObjectKind() == OK_Ordinary)(static_cast<void> (0));

  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<void> (0));
  assert(E->getObjectKind() == OK_Ordinary)(static_cast<void> (0));

  assert(isa<BlockPointerType>(E->getType()))(static_cast<void> (0));

  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!")__builtin_unreachable();
}
19506}

19508ExprResult 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;
19595}

19597/// Check a cast of an unknown-any type.  We intentionally only
19598/// trigger this for C-style casts.
19599ExprResult 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;
19617}

19619ExprResult Sema::forceUnknownAnyToType(Expr *E, QualType ToType) {
return RebuildUnknownAnyExpr(*this, ToType).Visit(E);
19621}

19623ExprResult 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<void> (0));
paramType = castArg->getTypeAsWritten();

// Copy-initialize a parameter of that type.
InitializedEntity entity =
  InitializedEntity::InitializeParameter(Context, paramType,
                                         /*consumed*/ false);
return PerformCopyInitialization(entity, callLoc, arg);
19644}

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

19689/// Check for operands with placeholder types and complain if found.
19690/// Returns ExprError() if there was an error and no recovery was possible.
19691ExprResult 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());
    if (FD->getBuiltinID() == 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());
    }
  }

  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.
19798#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
19800#include "clang/Basic/OpenCLImageTypes.def"
19801#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
19803#include "clang/Basic/OpenCLExtensionTypes.def"
19804#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
19806#include "clang/Basic/AArch64SVEACLETypes.def"
19807#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
19809#include "clang/Basic/PPCTypes.def"
19810#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
19811#include "clang/Basic/RISCVVTypes.def"
19812#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
19813#define PLACEHOLDER_TYPE(Id, SingletonId)
19814#include "clang/AST/BuiltinTypes.def"
  break;
}

llvm_unreachable("invalid placeholder type!")__builtin_unreachable();
19819}

19821bool Sema::CheckCaseExpression(Expr *E) {
if (E->isTypeDependent())
  return true;
if (E->isValueDependent() || E->isIntegerConstantExpr(Context))
  return E->getType()->isIntegralOrEnumerationType();
return false;
19827}

19829/// ActOnObjCBoolLiteral - Parse {__objc_yes,__objc_no} literals.
19830ExprResult
19831Sema::ActOnObjCBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) {
assert((Kind == tok::kw___objc_yes || Kind == tok::kw___objc_no) &&(static_cast<void> (0))
       "Unknown Objective-C Boolean value!")(static_cast<void> (0));
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);
19848}

19850ExprResult Sema::ActOnObjCAvailabilityCheckExpr(
  llvm::ArrayRef<AvailabilitySpec> AvailSpecs, SourceLocation AtLoc,
  SourceLocation RParen) {
auto FindSpecVersion = [&](StringRef Platform) -> 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 None;
  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);
19881}

19883ExprResult 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);
19897}

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include/clang/AST/Type.h

→

1//===- Type.h - C Language Family Type Representation -----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//

17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H

20#include "clang/AST/DependenceFlags.h"
21#include "clang/AST/NestedNameSpecifier.h"
22#include "clang/AST/TemplateName.h"
23#include "clang/Basic/AddressSpaces.h"
24#include "clang/Basic/AttrKinds.h"
25#include "clang/Basic/Diagnostic.h"
26#include "clang/Basic/ExceptionSpecificationType.h"
27#include "clang/Basic/LLVM.h"
28#include "clang/Basic/Linkage.h"
29#include "clang/Basic/PartialDiagnostic.h"
30#include "clang/Basic/SourceLocation.h"
31#include "clang/Basic/Specifiers.h"
32#include "clang/Basic/Visibility.h"
33#include "llvm/ADT/APInt.h"
34#include "llvm/ADT/APSInt.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/FoldingSet.h"
37#include "llvm/ADT/None.h"
38#include "llvm/ADT/Optional.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/Twine.h"
43#include "llvm/ADT/iterator_range.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/PointerLikeTypeTraits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include "llvm/Support/type_traits.h"
50#include <cassert>
51#include <cstddef>
52#include <cstdint>
53#include <cstring>
54#include <string>
55#include <type_traits>
56#include <utility>

58namespace clang {

60class ExtQuals;
61class QualType;
62class ConceptDecl;
63class TagDecl;
64class TemplateParameterList;
65class Type;

67enum {
TypeAlignmentInBits = 4,
TypeAlignment = 1 << TypeAlignmentInBits
70};

72namespace serialization {
template <class T> class AbstractTypeReader;
template <class T> class AbstractTypeWriter;
75}

77} // namespace clang

79namespace llvm {

template <typename T>
struct PointerLikeTypeTraits;
template<>
struct PointerLikeTypeTraits< ::clang::Type*> {
  static inline void *getAsVoidPointer(::clang::Type *P) { return P; }

  static inline ::clang::Type *getFromVoidPointer(void *P) {
    return static_cast< ::clang::Type*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

template<>
struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
  static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }

  static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
    return static_cast< ::clang::ExtQuals*>(P);
  }

  static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
};

105} // namespace llvm

107namespace clang {

109class ASTContext;
110template <typename> class CanQual;
111class CXXRecordDecl;
112class DeclContext;
113class EnumDecl;
114class Expr;
115class ExtQualsTypeCommonBase;
116class FunctionDecl;
117class IdentifierInfo;
118class NamedDecl;
119class ObjCInterfaceDecl;
120class ObjCProtocolDecl;
121class ObjCTypeParamDecl;
122struct PrintingPolicy;
123class RecordDecl;
124class Stmt;
125class TagDecl;
126class TemplateArgument;
127class TemplateArgumentListInfo;
128class TemplateArgumentLoc;
129class TemplateTypeParmDecl;
130class TypedefNameDecl;
131class UnresolvedUsingTypenameDecl;

133using CanQualType = CanQual<Type>;

135// Provide forward declarations for all of the *Type classes.
136#define TYPE(Class, Base) class Class##Type;
137#include "clang/AST/TypeNodes.inc"

139/// The collection of all-type qualifiers we support.
140/// Clang supports five independent qualifiers:
141/// * C99: const, volatile, and restrict
142/// * MS: __unaligned
143/// * Embedded C (TR18037): address spaces
144/// * Objective C: the GC attributes (none, weak, or strong)
145class Qualifiers {
146public:
enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
  Const    = 0x1,
  Restrict = 0x2,
  Volatile = 0x4,
  CVRMask = Const | Volatile | Restrict
};

enum GC {
  GCNone = 0,
  Weak,
  Strong
};

enum ObjCLifetime {
  /// There is no lifetime qualification on this type.
  OCL_None,

  /// This object can be modified without requiring retains or
  /// releases.
  OCL_ExplicitNone,

  /// Assigning into this object requires the old value to be
  /// released and the new value to be retained.  The timing of the
  /// release of the old value is inexact: it may be moved to
  /// immediately after the last known point where the value is
  /// live.
  OCL_Strong,

  /// Reading or writing from this object requires a barrier call.
  OCL_Weak,

  /// Assigning into this object requires a lifetime extension.
  OCL_Autoreleasing
};

enum {
  /// The maximum supported address space number.
  /// 23 bits should be enough for anyone.
  MaxAddressSpace = 0x7fffffu,

  /// The width of the "fast" qualifier mask.
  FastWidth = 3,

  /// The fast qualifier mask.
  FastMask = (1 << FastWidth) - 1
};

/// Returns the common set of qualifiers while removing them from
/// the given sets.
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
  // If both are only CVR-qualified, bit operations are sufficient.
  if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
    Qualifiers Q;
    Q.Mask = L.Mask & R.Mask;
    L.Mask &= ~Q.Mask;
    R.Mask &= ~Q.Mask;
    return Q;
  }

  Qualifiers Q;
  unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
  Q.addCVRQualifiers(CommonCRV);
  L.removeCVRQualifiers(CommonCRV);
  R.removeCVRQualifiers(CommonCRV);

  if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
    Q.setObjCGCAttr(L.getObjCGCAttr());
    L.removeObjCGCAttr();
    R.removeObjCGCAttr();
  }

  if (L.getObjCLifetime() == R.getObjCLifetime()) {
    Q.setObjCLifetime(L.getObjCLifetime());
    L.removeObjCLifetime();
    R.removeObjCLifetime();
  }

  if (L.getAddressSpace() == R.getAddressSpace()) {
    Q.setAddressSpace(L.getAddressSpace());
    L.removeAddressSpace();
    R.removeAddressSpace();
  }
  return Q;
}

static Qualifiers fromFastMask(unsigned Mask) {
  Qualifiers Qs;
  Qs.addFastQualifiers(Mask);
  return Qs;
}

static Qualifiers fromCVRMask(unsigned CVR) {
  Qualifiers Qs;
  Qs.addCVRQualifiers(CVR);
  return Qs;
}

static Qualifiers fromCVRUMask(unsigned CVRU) {
  Qualifiers Qs;
  Qs.addCVRUQualifiers(CVRU);
  return Qs;
}

// Deserialize qualifiers from an opaque representation.
static Qualifiers fromOpaqueValue(unsigned opaque) {
  Qualifiers Qs;
  Qs.Mask = opaque;
  return Qs;
}

// Serialize these qualifiers into an opaque representation.
unsigned getAsOpaqueValue() const {
  return Mask;
}

bool hasConst() const { return Mask & Const; }
bool hasOnlyConst() const { return Mask == Const; }
void removeConst() { Mask &= ~Const; }
void addConst() { Mask |= Const; }

bool hasVolatile() const { return Mask & Volatile; }
bool hasOnlyVolatile() const { return Mask == Volatile; }
void removeVolatile() { Mask &= ~Volatile; }
void addVolatile() { Mask |= Volatile; }

bool hasRestrict() const { return Mask & Restrict; }
bool hasOnlyRestrict() const { return Mask == Restrict; }
void removeRestrict() { Mask &= ~Restrict; }
void addRestrict() { Mask |= Restrict; }

bool hasCVRQualifiers() const { return getCVRQualifiers(); }
unsigned getCVRQualifiers() const { return Mask & CVRMask; }
unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }

void setCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")(static_cast<void> (0));
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")(static_cast<void> (0));
  Mask |= mask;
}

bool hasUnaligned() const { return Mask & UMask; }
void setUnaligned(bool flag) {
  Mask = (Mask & ~UMask) | (flag ? UMask : 0);
}
void removeUnaligned() { Mask &= ~UMask; }
void addUnaligned() { Mask |= UMask; }

bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
void setObjCGCAttr(GC type) {
  Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
}
void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
void addObjCGCAttr(GC type) {
  assert(type)(static_cast<void> (0));
  setObjCGCAttr(type);
}
Qualifiers withoutObjCGCAttr() const {
  Qualifiers qs = *this;
  qs.removeObjCGCAttr();
  return qs;
}
Qualifiers withoutObjCLifetime() const {
  Qualifiers qs = *this;
  qs.removeObjCLifetime();
  return qs;
}
Qualifiers withoutAddressSpace() const {
  Qualifiers qs = *this;
  qs.removeAddressSpace();
  return qs;
}

bool hasObjCLifetime() const { return Mask & LifetimeMask; }
ObjCLifetime getObjCLifetime() const {
  return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
}
void setObjCLifetime(ObjCLifetime type) {
  Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
}
void removeObjCLifetime() { setObjCLifetime(OCL_None); }
void addObjCLifetime(ObjCLifetime type) {
  assert(type)(static_cast<void> (0));
  assert(!hasObjCLifetime())(static_cast<void> (0));
  Mask |= (type << LifetimeShift);
}

/// True if the lifetime is neither None or ExplicitNone.
bool hasNonTrivialObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime > OCL_ExplicitNone);
}

/// True if the lifetime is either strong or weak.
bool hasStrongOrWeakObjCLifetime() const {
  ObjCLifetime lifetime = getObjCLifetime();
  return (lifetime == OCL_Strong || lifetime == OCL_Weak);
}

bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
LangAS getAddressSpace() const {
  return static_cast<LangAS>(Mask >> AddressSpaceShift);
}
bool hasTargetSpecificAddressSpace() const {
  return isTargetAddressSpace(getAddressSpace());
}
/// Get the address space attribute value to be printed by diagnostics.
unsigned getAddressSpaceAttributePrintValue() const {
  auto Addr = getAddressSpace();
  // This function is not supposed to be used with language specific
  // address spaces. If that happens, the diagnostic message should consider
  // printing the QualType instead of the address space value.
  assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())(static_cast<void> (0));
  if (Addr != LangAS::Default)
    return toTargetAddressSpace(Addr);
  // TODO: The diagnostic messages where Addr may be 0 should be fixed
  // since it cannot differentiate the situation where 0 denotes the default
  // address space or user specified __attribute__((address_space(0))).
  return 0;
}
void setAddressSpace(LangAS space) {
  assert((unsigned)space <= MaxAddressSpace)(static_cast<void> (0));
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)(static_cast<void> (0));
  setAddressSpace(space);
}

// Fast qualifiers are those that can be allocated directly
// on a QualType object.
bool hasFastQualifiers() const { return getFastQualifiers(); }
unsigned getFastQualifiers() const { return Mask & FastMask; }
void setFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")(static_cast<void> (0));
  Mask |= mask;
}

/// Return true if the set contains any qualifiers which require an ExtQuals
/// node to be allocated.
bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
Qualifiers getNonFastQualifiers() const {
  Qualifiers Quals = *this;
  Quals.setFastQualifiers(0);
  return Quals;
}

/// Return true if the set contains any qualifiers.
bool hasQualifiers() const { return Mask; }
bool empty() const { return !Mask; }

/// Add the qualifiers from the given set to this set.
void addQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-or it in.
  if (!(Q.Mask & ~CVRMask))
    Mask |= Q.Mask;
  else {
    Mask |= (Q.Mask & CVRMask);
    if (Q.hasAddressSpace())
      addAddressSpace(Q.getAddressSpace());
    if (Q.hasObjCGCAttr())
      addObjCGCAttr(Q.getObjCGCAttr());
    if (Q.hasObjCLifetime())
      addObjCLifetime(Q.getObjCLifetime());
  }
}

/// Remove the qualifiers from the given set from this set.
void removeQualifiers(Qualifiers Q) {
  // If the other set doesn't have any non-boolean qualifiers, just
  // bit-and the inverse in.
  if (!(Q.Mask & ~CVRMask))
    Mask &= ~Q.Mask;
  else {
    Mask &= ~(Q.Mask & CVRMask);
    if (getObjCGCAttr() == Q.getObjCGCAttr())
      removeObjCGCAttr();
    if (getObjCLifetime() == Q.getObjCLifetime())
      removeObjCLifetime();
    if (getAddressSpace() == Q.getAddressSpace())
      removeAddressSpace();
  }
}

/// Add the qualifiers from the given set to this set, given that
/// they don't conflict.
void addConsistentQualifiers(Qualifiers qs) {
  assert(getAddressSpace() == qs.getAddressSpace() ||(static_cast<void> (0))
         !hasAddressSpace() || !qs.hasAddressSpace())(static_cast<void> (0));
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||(static_cast<void> (0))
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())(static_cast<void> (0));
  assert(getObjCLifetime() == qs.getObjCLifetime() ||(static_cast<void> (0))
         !hasObjCLifetime() || !qs.hasObjCLifetime())(static_cast<void> (0));
  Mask |= qs.Mask;
}

/// Returns true if address space A is equal to or a superset of B.
/// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
/// overlapping address spaces.
/// CL1.1 or CL1.2:
///   every address space is a superset of itself.
/// CL2.0 adds:
///   __generic is a superset of any address space except for __constant.
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
  // Address spaces must match exactly.
  return A == B ||
         // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
         // for __constant can be used as __generic.
         (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
         // We also define global_device and global_host address spaces,
         // to distinguish global pointers allocated on host from pointers
         // allocated on device, which are a subset of __global.
         (A == LangAS::opencl_global && (B == LangAS::opencl_global_device ||
                                         B == LangAS::opencl_global_host)) ||
         (A == LangAS::sycl_global && (B == LangAS::sycl_global_device ||
                                       B == LangAS::sycl_global_host)) ||
         // Consider pointer size address spaces to be equivalent to default.
         ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
          (isPtrSizeAddressSpace(B) || B == LangAS::Default)) ||
         // Default is a superset of SYCL address spaces.
         (A == LangAS::Default &&
          (B == LangAS::sycl_private || B == LangAS::sycl_local ||
           B == LangAS::sycl_global || B == LangAS::sycl_global_device ||
           B == LangAS::sycl_global_host)) ||
         // In HIP device compilation, any cuda address space is allowed
         // to implicitly cast into the default address space.
         (A == LangAS::Default &&
          (B == LangAS::cuda_constant || B == LangAS::cuda_device ||
           B == LangAS::cuda_shared));
}

/// Returns true if the address space in these qualifiers is equal to or
/// a superset of the address space in the argument qualifiers.
bool isAddressSpaceSupersetOf(Qualifiers other) const {
  return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
}

/// Determines if these qualifiers compatibly include another set.
/// Generally this answers the question of whether an object with the other
/// qualifiers can be safely used as an object with these qualifiers.
bool compatiblyIncludes(Qualifiers other) const {
  return isAddressSpaceSupersetOf(other) &&
         // ObjC GC qualifiers can match, be added, or be removed, but can't
         // be changed.
         (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
          !other.hasObjCGCAttr()) &&
         // ObjC lifetime qualifiers must match exactly.
         getObjCLifetime() == other.getObjCLifetime() &&
         // CVR qualifiers may subset.
         (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
         // U qualifier may superset.
         (!other.hasUnaligned() || hasUnaligned());
}

/// Determines if these qualifiers compatibly include another set of
/// qualifiers from the narrow perspective of Objective-C ARC lifetime.
///
/// One set of Objective-C lifetime qualifiers compatibly includes the other
/// if the lifetime qualifiers match, or if both are non-__weak and the
/// including set also contains the 'const' qualifier, or both are non-__weak
/// and one is None (which can only happen in non-ARC modes).
bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
  if (getObjCLifetime() == other.getObjCLifetime())
    return true;

  if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
    return false;

  if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
    return true;

  return hasConst();
}

/// Determine whether this set of qualifiers is a strict superset of
/// another set of qualifiers, not considering qualifier compatibility.
bool isStrictSupersetOf(Qualifiers Other) const;

bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }

explicit operator bool() const { return hasQualifiers(); }

Qualifiers &operator+=(Qualifiers R) {
  addQualifiers(R);
  return *this;
}

// Union two qualifier sets.  If an enumerated qualifier appears
// in both sets, use the one from the right.
friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
  L += R;
  return L;
}

Qualifiers &operator-=(Qualifiers R) {
  removeQualifiers(R);
  return *this;
}

/// Compute the difference between two qualifier sets.
friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
  L -= R;
  return L;
}

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

static std::string getAddrSpaceAsString(LangAS AS);

bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
void print(raw_ostream &OS, const PrintingPolicy &Policy,
           bool appendSpaceIfNonEmpty = false) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddInteger(Mask);
}

594private:
// bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
//           |C R V|U|GCAttr|Lifetime|AddressSpace|
uint32_t Mask = 0;

static const uint32_t UMask = 0x8;
static const uint32_t UShift = 3;
static const uint32_t GCAttrMask = 0x30;
static const uint32_t GCAttrShift = 4;
static const uint32_t LifetimeMask = 0x1C0;
static const uint32_t LifetimeShift = 6;
static const uint32_t AddressSpaceMask =
    ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
static const uint32_t AddressSpaceShift = 9;
608};

610/// A std::pair-like structure for storing a qualified type split
611/// into its local qualifiers and its locally-unqualified type.
612struct SplitQualType {
/// The locally-unqualified type.
const Type *Ty = nullptr;

/// The local qualifiers.
Qualifiers Quals;

SplitQualType() = default;
SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}

SplitQualType getSingleStepDesugaredType() const; // end of this file

// Make std::tie work.
std::pair<const Type *,Qualifiers> asPair() const {
  return std::pair<const Type *, Qualifiers>(Ty, Quals);
}

friend bool operator==(SplitQualType a, SplitQualType b) {
  return a.Ty == b.Ty && a.Quals == b.Quals;
}
friend bool operator!=(SplitQualType a, SplitQualType b) {
  return a.Ty != b.Ty || a.Quals != b.Quals;
}
635};

637/// The kind of type we are substituting Objective-C type arguments into.
638///
639/// The kind of substitution affects the replacement of type parameters when
640/// no concrete type information is provided, e.g., when dealing with an
641/// unspecialized type.
642enum class ObjCSubstitutionContext {
/// An ordinary type.
Ordinary,

/// The result type of a method or function.
Result,

/// The parameter type of a method or function.
Parameter,

/// The type of a property.
Property,

/// The superclass of a type.
Superclass,
657};

659/// A (possibly-)qualified type.
660///
661/// For efficiency, we don't store CV-qualified types as nodes on their
662/// own: instead each reference to a type stores the qualifiers.  This
663/// greatly reduces the number of nodes we need to allocate for types (for
664/// example we only need one for 'int', 'const int', 'volatile int',
665/// 'const volatile int', etc).
666///
667/// As an added efficiency bonus, instead of making this a pair, we
668/// just store the two bits we care about in the low bits of the
669/// pointer.  To handle the packing/unpacking, we make QualType be a
670/// simple wrapper class that acts like a smart pointer.  A third bit
671/// indicates whether there are extended qualifiers present, in which
672/// case the pointer points to a special structure.
673class QualType {
friend class QualifierCollector;

// Thankfully, these are efficiently composable.
llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
                     Qualifiers::FastWidth> Value;

const ExtQuals *getExtQualsUnsafe() const {
  return Value.getPointer().get<const ExtQuals*>();
}

const Type *getTypePtrUnsafe() const {
  return Value.getPointer().get<const Type*>();
}

const ExtQualsTypeCommonBase *getCommonPtr() const {
  assert(!isNull() && "Cannot retrieve a NULL type pointer")(static_cast<void> (0));
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

695public:
QualType() = default;
QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}

unsigned getLocalFastQualifiers() const { return Value.getInt(); }
void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }

/// Retrieves a pointer to the underlying (unqualified) type.
///
/// This function requires that the type not be NULL. If the type might be
/// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
const Type *getTypePtr() const;

const Type *getTypePtrOrNull() const;

/// Retrieves a pointer to the name of the base type.
const IdentifierInfo *getBaseTypeIdentifier() const;

/// Divides a QualType into its unqualified type and a set of local
/// qualifiers.
SplitQualType split() const;

void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }

static QualType getFromOpaquePtr(const void *Ptr) {
  QualType T;
  T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
  return T;
}

const Type &operator*() const {
  return *getTypePtr();
}

const Type *operator->() const {
  return getTypePtr();
}

bool isCanonical() const;
bool isCanonicalAsParam() const;

/// Return true if this QualType doesn't point to a type yet.
bool isNull() const {
  return Value.getPointer().isNull();
}

/// Determine whether this particular QualType instance has the
/// "const" qualifier set, without looking through typedefs that may have
/// added "const" at a different level.
bool isLocalConstQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Const);
}

/// Determine whether this type is const-qualified.
bool isConstQualified() const;

/// Determine whether this particular QualType instance has the
/// "restrict" qualifier set, without looking through typedefs that may have
/// added "restrict" at a different level.
bool isLocalRestrictQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Restrict);
}

/// Determine whether this type is restrict-qualified.
bool isRestrictQualified() const;

/// Determine whether this particular QualType instance has the
/// "volatile" qualifier set, without looking through typedefs that may have
/// added "volatile" at a different level.
bool isLocalVolatileQualified() const {
  return (getLocalFastQualifiers() & Qualifiers::Volatile);
}

/// Determine whether this type is volatile-qualified.
bool isVolatileQualified() const;

/// Determine whether this particular QualType instance has any
/// qualifiers, without looking through any typedefs that might add
/// qualifiers at a different level.
bool hasLocalQualifiers() const {
  return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
}

/// Determine whether this type has any qualifiers.
bool hasQualifiers() const;

/// Determine whether this particular QualType instance has any
/// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
/// instance.
bool hasLocalNonFastQualifiers() const {
  return Value.getPointer().is<const ExtQuals*>();
}

/// Retrieve the set of qualifiers local to this particular QualType
/// instance, not including any qualifiers acquired through typedefs or
/// other sugar.
Qualifiers getLocalQualifiers() const;

/// Retrieve the set of qualifiers applied to this type.
Qualifiers getQualifiers() const;

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// local to this particular QualType instance, not including any qualifiers
/// acquired through typedefs or other sugar.
unsigned getLocalCVRQualifiers() const {
  return getLocalFastQualifiers();
}

/// Retrieve the set of CVR (const-volatile-restrict) qualifiers
/// applied to this type.
unsigned getCVRQualifiers() const;

bool isConstant(const ASTContext& Ctx) const {
  return QualType::isConstant(*this, Ctx);
}

/// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
bool isPODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the rules of the C++98
/// standard, regardless of the current compilation's language.
bool isCXX98PODType(const ASTContext &Context) const;

/// Return true if this is a POD type according to the more relaxed rules
/// of the C++11 standard, regardless of the current compilation's language.
/// (C++0x [basic.types]p9). Note that, unlike
/// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
bool isCXX11PODType(const ASTContext &Context) const;

/// Return true if this is a trivial type per (C++0x [basic.types]p9)
bool isTrivialType(const ASTContext &Context) const;

/// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
bool isTriviallyCopyableType(const ASTContext &Context) const;


/// Returns true if it is a class and it might be dynamic.
bool mayBeDynamicClass() const;

/// Returns true if it is not a class or if the class might not be dynamic.
bool mayBeNotDynamicClass() const;

// Don't promise in the API that anything besides 'const' can be
// easily added.

/// Add the `const` type qualifier to this QualType.
void addConst() {
  addFastQualifiers(Qualifiers::Const);
}
QualType withConst() const {
  return withFastQualifiers(Qualifiers::Const);
}

/// Add the `volatile` type qualifier to this QualType.
void addVolatile() {
  addFastQualifiers(Qualifiers::Volatile);
}
QualType withVolatile() const {
  return withFastQualifiers(Qualifiers::Volatile);
}

/// Add the `restrict` qualifier to this QualType.
void addRestrict() {
  addFastQualifiers(Qualifiers::Restrict);
}
QualType withRestrict() const {
  return withFastQualifiers(Qualifiers::Restrict);
}

QualType withCVRQualifiers(unsigned CVR) const {
  return withFastQualifiers(CVR);
}

void addFastQualifiers(unsigned TQs) {
  assert(!(TQs & ~Qualifiers::FastMask)(static_cast<void> (0))
         && "non-fast qualifier bits set in mask!")(static_cast<void> (0));
  Value.setInt(Value.getInt() | TQs);
}

void removeLocalConst();
void removeLocalVolatile();
void removeLocalRestrict();
void removeLocalCVRQualifiers(unsigned Mask);

void removeLocalFastQualifiers() { Value.setInt(0); }
void removeLocalFastQualifiers(unsigned Mask) {
  assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")(static_cast<void> (0));
  Value.setInt(Value.getInt() & ~Mask);
}

// Creates a type with the given qualifiers in addition to any
// qualifiers already on this type.
QualType withFastQualifiers(unsigned TQs) const {
  QualType T = *this;
  T.addFastQualifiers(TQs);
  return T;
}

// Creates a type with exactly the given fast qualifiers, removing
// any existing fast qualifiers.
QualType withExactLocalFastQualifiers(unsigned TQs) const {
  return withoutLocalFastQualifiers().withFastQualifiers(TQs);
}

// Removes fast qualifiers, but leaves any extended qualifiers in place.
QualType withoutLocalFastQualifiers() const {
  QualType T = *this;
  T.removeLocalFastQualifiers();
  return T;
}

QualType getCanonicalType() const;

/// Return this type with all of the instance-specific qualifiers
/// removed, but without removing any qualifiers that may have been applied
/// through typedefs.
QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }

/// Retrieve the unqualified variant of the given type,
/// removing as little sugar as possible.
///
/// This routine looks through various kinds of sugar to find the
/// least-desugared type that is unqualified. For example, given:
///
/// \code
/// typedef int Integer;
/// typedef const Integer CInteger;
/// typedef CInteger DifferenceType;
/// \endcode
///
/// Executing \c getUnqualifiedType() on the type \c DifferenceType will
/// desugar until we hit the type \c Integer, which has no qualifiers on it.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline QualType getUnqualifiedType() const;

/// Retrieve the unqualified variant of the given type, removing as little
/// sugar as possible.
///
/// Like getUnqualifiedType(), but also returns the set of
/// qualifiers that were built up.
///
/// The resulting type might still be qualified if it's sugar for an array
/// type.  To strip qualifiers even from within a sugared array type, use
/// ASTContext::getUnqualifiedArrayType.
inline SplitQualType getSplitUnqualifiedType() const;

/// Determine whether this type is more qualified than the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isMoreQualifiedThan(QualType Other) const;

/// Determine whether this type is at least as qualified as the other
/// given type, requiring exact equality for non-CVR qualifiers.
bool isAtLeastAsQualifiedAs(QualType Other) const;

QualType getNonReferenceType() const;

/// Determine the type of a (typically non-lvalue) expression with the
/// specified result type.
///
/// This routine should be used for expressions for which the return type is
/// explicitly specified (e.g., in a cast or call) and isn't necessarily
/// an lvalue. It removes a top-level reference (since there are no
/// expressions of reference type) and deletes top-level cvr-qualifiers
/// from non-class types (in C++) or all types (in C).
QualType getNonLValueExprType(const ASTContext &Context) const;

/// Remove an outer pack expansion type (if any) from this type. Used as part
/// of converting the type of a declaration to the type of an expression that
/// references that expression. It's meaningless for an expression to have a
/// pack expansion type.
QualType getNonPackExpansionType() const;

/// Return the specified type with any "sugar" removed from
/// the type.  This takes off typedefs, typeof's etc.  If the outer level of
/// the type is already concrete, it returns it unmodified.  This is similar
/// to getting the canonical type, but it doesn't remove *all* typedefs.  For
/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
/// concrete.
///
/// Qualifiers are left in place.
QualType getDesugaredType(const ASTContext &Context) const {
  return getDesugaredType(*this, Context);
}

SplitQualType getSplitDesugaredType() const {
  return getSplitDesugaredType(*this);
}

/// Return the specified type with one level of "sugar" removed from
/// the type.
///
/// This routine takes off the first typedef, typeof, etc. If the outer level
/// of the type is already concrete, it returns it unmodified.
QualType getSingleStepDesugaredType(const ASTContext &Context) const {
  return getSingleStepDesugaredTypeImpl(*this, Context);
}

/// Returns the specified type after dropping any
/// outer-level parentheses.
QualType IgnoreParens() const {
  if (isa<ParenType>(*this))
    return QualType::IgnoreParens(*this);
  return *this;
}

/// Indicate whether the specified types and qualifiers are identical.
friend bool operator==(const QualType &LHS, const QualType &RHS) {
  return LHS.Value == RHS.Value;
}
friend bool operator!=(const QualType &LHS, const QualType &RHS) {
  return LHS.Value != RHS.Value;
}
friend bool operator<(const QualType &LHS, const QualType &RHS) {
  return LHS.Value < RHS.Value;
}

static std::string getAsString(SplitQualType split,
                               const PrintingPolicy &Policy) {
  return getAsString(split.Ty, split.Quals, Policy);
}
static std::string getAsString(const Type *ty, Qualifiers qs,
                               const PrintingPolicy &Policy);

std::string getAsString() const;
std::string getAsString(const PrintingPolicy &Policy) const;

void print(raw_ostream &OS, const PrintingPolicy &Policy,
           const Twine &PlaceHolder = Twine(),
           unsigned Indentation = 0) const;

static void print(SplitQualType split, raw_ostream &OS,
                  const PrintingPolicy &policy, const Twine &PlaceHolder,
                  unsigned Indentation = 0) {
  return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
}

static void print(const Type *ty, Qualifiers qs,
                  raw_ostream &OS, const PrintingPolicy &policy,
                  const Twine &PlaceHolder,
                  unsigned Indentation = 0);

void getAsStringInternal(std::string &Str,
                         const PrintingPolicy &Policy) const;

static void getAsStringInternal(SplitQualType split, std::string &out,
                                const PrintingPolicy &policy) {
  return getAsStringInternal(split.Ty, split.Quals, out, policy);
}

static void getAsStringInternal(const Type *ty, Qualifiers qs,
                                std::string &out,
                                const PrintingPolicy &policy);

class StreamedQualTypeHelper {
  const QualType &T;
  const PrintingPolicy &Policy;
  const Twine &PlaceHolder;
  unsigned Indentation;

public:
  StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
                         const Twine &PlaceHolder, unsigned Indentation)
      : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
        Indentation(Indentation) {}

  friend raw_ostream &operator<<(raw_ostream &OS,
                                 const StreamedQualTypeHelper &SQT) {
    SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
    return OS;
  }
};

StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
                              const Twine &PlaceHolder = Twine(),
                              unsigned Indentation = 0) const {
  return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
}

void dump(const char *s) const;
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;

void Profile(llvm::FoldingSetNodeID &ID) const {
  ID.AddPointer(getAsOpaquePtr());
}

/// Check if this type has any address space qualifier.
inline bool hasAddressSpace() const;

/// Return the address space of this type.
inline LangAS getAddressSpace() const;

/// Returns true if address space qualifiers overlap with T address space
/// qualifiers.
/// OpenCL C defines conversion rules for pointers to different address spaces
/// and notion of overlapping address spaces.
/// CL1.1 or CL1.2:
///   address spaces overlap iff they are they same.
/// OpenCL C v2.0 s6.5.5 adds:
///   __generic overlaps with any address space except for __constant.
bool isAddressSpaceOverlapping(QualType T) const {
  Qualifiers Q = getQualifiers();
  Qualifiers TQ = T.getQualifiers();
  // Address spaces overlap if at least one of them is a superset of another
  return Q.isAddressSpaceSupersetOf(TQ) || TQ.isAddressSpaceSupersetOf(Q);
}

/// Returns gc attribute of this type.
inline Qualifiers::GC getObjCGCAttr() const;

/// true when Type is objc's weak.
bool isObjCGCWeak() const {
  return getObjCGCAttr() == Qualifiers::Weak;
}

/// true when Type is objc's strong.
bool isObjCGCStrong() const {
  return getObjCGCAttr() == Qualifiers::Strong;
}

/// Returns lifetime attribute of this type.
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return getQualifiers().getObjCLifetime();
}

bool hasNonTrivialObjCLifetime() const {
  return getQualifiers().hasNonTrivialObjCLifetime();
}

bool hasStrongOrWeakObjCLifetime() const {
  return getQualifiers().hasStrongOrWeakObjCLifetime();
}

// true when Type is objc's weak and weak is enabled but ARC isn't.
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;

enum PrimitiveDefaultInitializeKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PDIK_Trivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PDIK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PDIK_ARCWeak,

  /// The type is a struct containing a field whose type is not PCK_Trivial.
  PDIK_Struct
};

/// Functions to query basic properties of non-trivial C struct types.

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to default initialize
/// and return the kind.
PrimitiveDefaultInitializeKind
isNonTrivialToPrimitiveDefaultInitialize() const;

enum PrimitiveCopyKind {
  /// The type does not fall into any of the following categories. Note that
  /// this case is zero-valued so that values of this enum can be used as a
  /// boolean condition for non-triviality.
  PCK_Trivial,

  /// The type would be trivial except that it is volatile-qualified. Types
  /// that fall into one of the other non-trivial cases may additionally be
  /// volatile-qualified.
  PCK_VolatileTrivial,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __strong qualifier.
  PCK_ARCStrong,

  /// The type is an Objective-C retainable pointer type that is qualified
  /// with the ARC __weak qualifier.
  PCK_ARCWeak,

  /// The type is a struct containing a field whose type is neither
  /// PCK_Trivial nor PCK_VolatileTrivial.
  /// Note that a C++ struct type does not necessarily match this; C++ copying
  /// semantics are too complex to express here, in part because they depend
  /// on the exact constructor or assignment operator that is chosen by
  /// overload resolution to do the copy.
  PCK_Struct
};

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to copy and return the
/// kind.
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;

/// Check if this is a non-trivial type that would cause a C struct
/// transitively containing this type to be non-trivial to destructively
/// move and return the kind. Destructive move in this context is a C++-style
/// move in which the source object is placed in a valid but unspecified state
/// after it is moved, as opposed to a truly destructive move in which the
/// source object is placed in an uninitialized state.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;

enum DestructionKind {
  DK_none,
  DK_cxx_destructor,
  DK_objc_strong_lifetime,
  DK_objc_weak_lifetime,
  DK_nontrivial_c_struct
};

/// Returns a nonzero value if objects of this type require
/// non-trivial work to clean up after.  Non-zero because it's
/// conceivable that qualifiers (objc_gc(weak)?) could make
/// something require destruction.
DestructionKind isDestructedType() const {
  return isDestructedTypeImpl(*this);
}

/// Check if this is or contains a C union that is non-trivial to
/// default-initialize, which is a union that has a member that is non-trivial
/// to default-initialize. If this returns true,
/// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;

/// Check if this is or contains a C union that is non-trivial to destruct,
/// which is a union that has a member that is non-trivial to destruct. If
/// this returns true, isDestructedType returns DK_nontrivial_c_struct.
bool hasNonTrivialToPrimitiveDestructCUnion() const;

/// Check if this is or contains a C union that is non-trivial to copy, which
/// is a union that has a member that is non-trivial to copy. If this returns
/// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
bool hasNonTrivialToPrimitiveCopyCUnion() const;

/// Determine whether expressions of the given type are forbidden
/// from being lvalues in C.
///
/// The expression types that are forbidden to be lvalues are:
///   - 'void', but not qualified void
///   - function types
///
/// The exact rule here is C99 6.3.2.1:
///   An lvalue is an expression with an object type or an incomplete
///   type other than void.
bool isCForbiddenLValueType() const;

/// Substitute type arguments for the Objective-C type parameters used in the
/// subject type.
///
/// \param ctx ASTContext in which the type exists.
///
/// \param typeArgs The type arguments that will be substituted for the
/// Objective-C type parameters in the subject type, which are generally
/// computed via \c Type::getObjCSubstitutions. If empty, the type
/// parameters will be replaced with their bounds or id/Class, as appropriate
/// for the context.
///
/// \param context The context in which the subject type was written.
///
/// \returns the resulting type.
QualType substObjCTypeArgs(ASTContext &ctx,
                           ArrayRef<QualType> typeArgs,
                           ObjCSubstitutionContext context) const;

/// Substitute type arguments from an object type for the Objective-C type
/// parameters used in the subject type.
///
/// This operation combines the computation of type arguments for
/// substitution (\c Type::getObjCSubstitutions) with the actual process of
/// substitution (\c QualType::substObjCTypeArgs) for the convenience of
/// callers that need to perform a single substitution in isolation.
///
/// \param objectType The type of the object whose member type we're
/// substituting into. For example, this might be the receiver of a message
/// or the base of a property access.
///
/// \param dc The declaration context from which the subject type was
/// retrieved, which indicates (for example) which type parameters should
/// be substituted.
///
/// \param context The context in which the subject type was written.
///
/// \returns the subject type after replacing all of the Objective-C type
/// parameters with their corresponding arguments.
QualType substObjCMemberType(QualType objectType,
                             const DeclContext *dc,
                             ObjCSubstitutionContext context) const;

/// Strip Objective-C "__kindof" types from the given type.
QualType stripObjCKindOfType(const ASTContext &ctx) const;

/// Remove all qualifiers including _Atomic.
QualType getAtomicUnqualifiedType() const;

1294private:
// These methods are implemented in a separate translation unit;
// "static"-ize them to avoid creating temporary QualTypes in the
// caller.
static bool isConstant(QualType T, const ASTContext& Ctx);
static QualType getDesugaredType(QualType T, const ASTContext &Context);
static SplitQualType getSplitDesugaredType(QualType T);
static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
static QualType getSingleStepDesugaredTypeImpl(QualType type,
                                               const ASTContext &C);
static QualType IgnoreParens(QualType T);
static DestructionKind isDestructedTypeImpl(QualType type);

/// Check if \param RD is or contains a non-trivial C union.
static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1311};

1313} // namespace clang

1315namespace llvm {

1317/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1318/// to a specific Type class.
1319template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1325};

1327// Teach SmallPtrSet that QualType is "basically a pointer".
1328template<>
1329struct PointerLikeTypeTraits<clang::QualType> {
static inline void *getAsVoidPointer(clang::QualType P) {
  return P.getAsOpaquePtr();
}

static inline clang::QualType getFromVoidPointer(void *P) {
  return clang::QualType::getFromOpaquePtr(P);
}

// Various qualifiers go in low bits.
static constexpr int NumLowBitsAvailable = 0;
1340};

1342} // namespace llvm

1344namespace clang {

1346/// Base class that is common to both the \c ExtQuals and \c Type
1347/// classes, which allows \c QualType to access the common fields between the
1348/// two.
1349class ExtQualsTypeCommonBase {
friend class ExtQuals;
friend class QualType;
friend class Type;

/// The "base" type of an extended qualifiers type (\c ExtQuals) or
/// a self-referential pointer (for \c Type).
///
/// This pointer allows an efficient mapping from a QualType to its
/// underlying type pointer.
const Type *const BaseType;

/// The canonical type of this type.  A QualType.
QualType CanonicalType;

ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
    : BaseType(baseType), CanonicalType(canon) {}
1366};

1368/// We can encode up to four bits in the low bits of a
1369/// type pointer, but there are many more type qualifiers that we want
1370/// to be able to apply to an arbitrary type.  Therefore we have this
1371/// struct, intended to be heap-allocated and used by QualType to
1372/// store qualifiers.
1373///
1374/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1375/// in three low bits on the QualType pointer; a fourth bit records whether
1376/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1377/// Objective-C GC attributes) are much more rare.
1378class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
// NOTE: changing the fast qualifiers should be straightforward as
// long as you don't make 'const' non-fast.
// 1. Qualifiers:
//    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
//       Fast qualifiers must occupy the low-order bits.
//    b) Update Qualifiers::FastWidth and FastMask.
// 2. QualType:
//    a) Update is{Volatile,Restrict}Qualified(), defined inline.
//    b) Update remove{Volatile,Restrict}, defined near the end of
//       this header.
// 3. ASTContext:
//    a) Update get{Volatile,Restrict}Type.

/// The immutable set of qualifiers applied by this node. Always contains
/// extended qualifiers.
Qualifiers Quals;

ExtQuals *this_() { return this; }

1398public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()(static_cast<void> (0))
         && "ExtQuals created with no fast qualifiers")(static_cast<void> (0));
  assert(!Quals.hasFastQualifiers()(static_cast<void> (0))
         && "ExtQuals created with fast qualifiers")(static_cast<void> (0));
}

Qualifiers getQualifiers() const { return Quals; }

bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }

bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
Qualifiers::ObjCLifetime getObjCLifetime() const {
  return Quals.getObjCLifetime();
}

bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
LangAS getAddressSpace() const { return Quals.getAddressSpace(); }

const Type *getBaseType() const { return BaseType; }

1424public:
void Profile(llvm::FoldingSetNodeID &ID) const {
  Profile(ID, getBaseType(), Quals);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const Type *BaseType,
                    Qualifiers Quals) {
  assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!")(static_cast<void> (0));
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1436};

1438/// The kind of C++11 ref-qualifier associated with a function type.
1439/// This determines whether a member function's "this" object can be an
1440/// lvalue, rvalue, or neither.
1441enum RefQualifierKind {
/// No ref-qualifier was provided.
RQ_None = 0,

/// An lvalue ref-qualifier was provided (\c &).
RQ_LValue,

/// An rvalue ref-qualifier was provided (\c &&).
RQ_RValue
1450};

1452/// Which keyword(s) were used to create an AutoType.
1453enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1462};

1464/// The base class of the type hierarchy.
1465///
1466/// A central concept with types is that each type always has a canonical
1467/// type.  A canonical type is the type with any typedef names stripped out
1468/// of it or the types it references.  For example, consider:
1469///
1470///  typedef int  foo;
1471///  typedef foo* bar;
1472///    'int *'    'foo *'    'bar'
1473///
1474/// There will be a Type object created for 'int'.  Since int is canonical, its
1475/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1476/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1477/// there is a PointerType that represents 'int*', which, like 'int', is
1478/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1479/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1480/// is also 'int*'.
1481///
1482/// Non-canonical types are useful for emitting diagnostics, without losing
1483/// information about typedefs being used.  Canonical types are useful for type
1484/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1485/// about whether something has a particular form (e.g. is a function type),
1486/// because they implicitly, recursively, strip all typedefs out of a type.
1487///
1488/// Types, once created, are immutable.
1489///
1490class alignas(8) Type : public ExtQualsTypeCommonBase {
1491public:
enum TypeClass {
1493#define TYPE(Class, Base) Class,
1494#define LAST_TYPE(Class) TypeLast = Class
1495#define ABSTRACT_TYPE(Class, Base)
1496#include "clang/AST/TypeNodes.inc"
};

1499private:
/// Bitfields required by the Type class.
class TypeBitfields {
  friend class Type;
  template <class T> friend class TypePropertyCache;

  /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
  unsigned TC : 8;

  /// Store information on the type dependency.
  unsigned Dependence : llvm::BitWidth<TypeDependence>;

  /// True if the cache (i.e. the bitfields here starting with
  /// 'Cache') is valid.
  mutable unsigned CacheValid : 1;

  /// Linkage of this type.
  mutable unsigned CachedLinkage : 3;

  /// Whether this type involves and local or unnamed types.
  mutable unsigned CachedLocalOrUnnamed : 1;

  /// Whether this type comes from an AST file.
  mutable unsigned FromAST : 1;

  bool isCacheValid() const {
    return CacheValid;
  }

  Linkage getLinkage() const {
    assert(isCacheValid() && "getting linkage from invalid cache")(static_cast<void> (0));
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")(static_cast<void> (0));
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };

1540protected:
// These classes allow subclasses to somewhat cleanly pack bitfields
// into Type.

class ArrayTypeBitfields {
  friend class ArrayType;

  unsigned : NumTypeBits;

  /// CVR qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  unsigned IndexTypeQuals : 3;

  /// Storage class qualifiers from declarations like
  /// 'int X[static restrict 4]'. For function parameters only.
  /// Actually an ArrayType::ArraySizeModifier.
  unsigned SizeModifier : 3;
};

class ConstantArrayTypeBitfields {
  friend class ConstantArrayType;

  unsigned : NumTypeBits + 3 + 3;

  /// Whether we have a stored size expression.
  unsigned HasStoredSizeExpr : 1;
};

class BuiltinTypeBitfields {
  friend class BuiltinType;

  unsigned : NumTypeBits;

  /// The kind (BuiltinType::Kind) of builtin type this is.
  unsigned Kind : 8;
};

/// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
/// Only common bits are stored here. Additional uncommon bits are stored
/// in a trailing object after FunctionProtoType.
class FunctionTypeBitfields {
  friend class FunctionProtoType;
  friend class FunctionType;

  unsigned : NumTypeBits;

  /// Extra information which affects how the function is called, like
  /// regparm and the calling convention.
  unsigned ExtInfo : 13;

  /// The ref-qualifier associated with a \c FunctionProtoType.
  ///
  /// This is a value of type \c RefQualifierKind.
  unsigned RefQualifier : 2;

  /// Used only by FunctionProtoType, put here to pack with the
  /// other bitfields.
  /// The qualifiers are part of FunctionProtoType because...
  ///
  /// C++ 8.3.5p4: The return type, the parameter type list and the
  /// cv-qualifier-seq, [...], are part of the function type.
  unsigned FastTypeQuals : Qualifiers::FastWidth;
  /// Whether this function has extended Qualifiers.
  unsigned HasExtQuals : 1;

  /// The number of parameters this function has, not counting '...'.
  /// According to [implimits] 8 bits should be enough here but this is
  /// somewhat easy to exceed with metaprogramming and so we would like to
  /// keep NumParams as wide as reasonably possible.
  unsigned NumParams : 16;

  /// The type of exception specification this function has.
  unsigned ExceptionSpecType : 4;

  /// Whether this function has extended parameter information.
  unsigned HasExtParameterInfos : 1;

  /// Whether the function is variadic.
  unsigned Variadic : 1;

  /// Whether this function has a trailing return type.
  unsigned HasTrailingReturn : 1;
};

class ObjCObjectTypeBitfields {
  friend class ObjCObjectType;

  unsigned : NumTypeBits;

  /// The number of type arguments stored directly on this object type.
  unsigned NumTypeArgs : 7;

  /// The number of protocols stored directly on this object type.
  unsigned NumProtocols : 6;

  /// Whether this is a "kindof" type.
  unsigned IsKindOf : 1;
};

class ReferenceTypeBitfields {
  friend class ReferenceType;

  unsigned : NumTypeBits;

  /// True if the type was originally spelled with an lvalue sigil.
  /// This is never true of rvalue references but can also be false
  /// on lvalue references because of C++0x [dcl.typedef]p9,
  /// as follows:
  ///
  ///   typedef int &ref;    // lvalue, spelled lvalue
  ///   typedef int &&rvref; // rvalue
  ///   ref &a;              // lvalue, inner ref, spelled lvalue
  ///   ref &&a;             // lvalue, inner ref
  ///   rvref &a;            // lvalue, inner ref, spelled lvalue
  ///   rvref &&a;           // rvalue, inner ref
  unsigned SpelledAsLValue : 1;

  /// True if the inner type is a reference type.  This only happens
  /// in non-canonical forms.
  unsigned InnerRef : 1;
};

class TypeWithKeywordBitfields {
  friend class TypeWithKeyword;

  unsigned : NumTypeBits;

  /// An ElaboratedTypeKeyword.  8 bits for efficient access.
  unsigned Keyword : 8;
};

enum { NumTypeWithKeywordBits = 8 };

class ElaboratedTypeBitfields {
  friend class ElaboratedType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// Whether the ElaboratedType has a trailing OwnedTagDecl.
  unsigned HasOwnedTagDecl : 1;
};

class VectorTypeBitfields {
  friend class VectorType;
  friend class DependentVectorType;

  unsigned : NumTypeBits;

  /// The kind of vector, either a generic vector type or some
  /// target-specific vector type such as for AltiVec or Neon.
  unsigned VecKind : 3;
  /// The number of elements in the vector.
  uint32_t NumElements;
};

class AttributedTypeBitfields {
  friend class AttributedType;

  unsigned : NumTypeBits;

  /// An AttributedType::Kind
  unsigned AttrKind : 32 - NumTypeBits;
};

class AutoTypeBitfields {
  friend class AutoType;

  unsigned : NumTypeBits;

  /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
  /// or '__auto_type'?  AutoTypeKeyword value.
  unsigned Keyword : 2;

  /// The number of template arguments in the type-constraints, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class SubstTemplateTypeParmPackTypeBitfields {
  friend class SubstTemplateTypeParmPackType;

  unsigned : NumTypeBits;

  /// The number of template arguments in \c Arguments, which is
  /// expected to be able to hold at least 1024 according to [implimits].
  /// However as this limit is somewhat easy to hit with template
  /// metaprogramming we'd prefer to keep it as large as possible.
  /// At the moment it has been left as a non-bitfield since this type
  /// safely fits in 64 bits as an unsigned, so there is no reason to
  /// introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class TemplateSpecializationTypeBitfields {
  friend class TemplateSpecializationType;

  unsigned : NumTypeBits;

  /// Whether this template specialization type is a substituted type alias.
  unsigned TypeAlias : 1;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class DependentTemplateSpecializationTypeBitfields {
  friend class DependentTemplateSpecializationType;

  unsigned : NumTypeBits;
  unsigned : NumTypeWithKeywordBits;

  /// The number of template arguments named in this class template
  /// specialization, which is expected to be able to hold at least 1024
  /// according to [implimits]. However, as this limit is somewhat easy to
  /// hit with template metaprogramming we'd prefer to keep it as large
  /// as possible. At the moment it has been left as a non-bitfield since
  /// this type safely fits in 64 bits as an unsigned, so there is no reason
  /// to introduce the performance impact of a bitfield.
  unsigned NumArgs;
};

class PackExpansionTypeBitfields {
  friend class PackExpansionType;

  unsigned : NumTypeBits;

  /// The number of expansions that this pack expansion will
  /// generate when substituted (+1), which is expected to be able to
  /// hold at least 1024 according to [implimits]. However, as this limit
  /// is somewhat easy to hit with template metaprogramming we'd prefer to
  /// keep it as large as possible. At the moment it has been left as a
  /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
  /// there is no reason to introduce the performance impact of a bitfield.
  ///
  /// This field will only have a non-zero value when some of the parameter
  /// packs that occur within the pattern have been substituted but others
  /// have not.
  unsigned NumExpansions;
};

union {
  TypeBitfields TypeBits;
  ArrayTypeBitfields ArrayTypeBits;
  ConstantArrayTypeBitfields ConstantArrayTypeBits;
  AttributedTypeBitfields AttributedTypeBits;
  AutoTypeBitfields AutoTypeBits;
  BuiltinTypeBitfields BuiltinTypeBits;
  FunctionTypeBitfields FunctionTypeBits;
  ObjCObjectTypeBitfields ObjCObjectTypeBits;
  ReferenceTypeBitfields ReferenceTypeBits;
  TypeWithKeywordBitfields TypeWithKeywordBits;
  ElaboratedTypeBitfields ElaboratedTypeBits;
  VectorTypeBitfields VectorTypeBits;
  SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
  TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
  DependentTemplateSpecializationTypeBitfields
    DependentTemplateSpecializationTypeBits;
  PackExpansionTypeBitfields PackExpansionTypeBits;
};

1812private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1820protected:
friend class ASTContext;

Type(TypeClass tc, QualType canon, TypeDependence Dependence)
    : ExtQualsTypeCommonBase(this,
                             canon.isNull() ? QualType(this_(), 0) : canon) {
  static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
                "changing bitfields changed sizeof(Type)!");
  static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
                "Insufficient alignment!");
  TypeBits.TC = tc;
  TypeBits.Dependence = static_cast<unsigned>(Dependence);
  TypeBits.CacheValid = false;
  TypeBits.CachedLocalOrUnnamed = false;
  TypeBits.CachedLinkage = NoLinkage;
  TypeBits.FromAST = false;
}

// silence VC++ warning C4355: 'this' : used in base member initializer list
Type *this_() { return this; }

void setDependence(TypeDependence D) {
  TypeBits.Dependence = static_cast<unsigned>(D);
}

void addDependence(TypeDependence D) { setDependence(getDependence() | D); }

1847public:
friend class ASTReader;
friend class ASTWriter;
template <class T> friend class serialization::AbstractTypeReader;
template <class T> friend class serialization::AbstractTypeWriter;

Type(const Type &) = delete;
Type(Type &&) = delete;
Type &operator=(const Type &) = delete;
Type &operator=(Type &&) = delete;

TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }

/// Whether this type comes from an AST file.
bool isFromAST() const { return TypeBits.FromAST; }

/// Whether this type is or contains an unexpanded parameter
/// pack, used to support C++0x variadic templates.
///
/// A type that contains a parameter pack shall be expanded by the
/// ellipsis operator at some point. For example, the typedef in the
/// following example contains an unexpanded parameter pack 'T':
///
/// \code
/// template<typename ...T>
/// struct X {
///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
/// };
/// \endcode
///
/// Note that this routine does not specify which
bool containsUnexpandedParameterPack() const {
  return getDependence() & TypeDependence::UnexpandedPack;
}

/// Determines if this type would be canonical if it had no further
/// qualification.
bool isCanonicalUnqualified() const {
  return CanonicalType == QualType(this, 0);
}

/// Pull a single level of sugar off of this locally-unqualified type.
/// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
/// or QualType::getSingleStepDesugaredType(const ASTContext&).
QualType getLocallyUnqualifiedSingleStepDesugaredType() const;

/// As an extension, we classify types as one of "sized" or "sizeless";
/// every type is one or the other.  Standard types are all sized;
/// sizeless types are purely an extension.
///
/// Sizeless types contain data with no specified size, alignment,
/// or layout.
bool isSizelessType() const;
bool isSizelessBuiltinType() const;

/// Determines if this is a sizeless type supported by the
/// 'arm_sve_vector_bits' type attribute, which can be applied to a single
/// SVE vector or predicate, excluding tuple types such as svint32x4_t.
bool isVLSTBuiltinType() const;

/// Returns the representative type for the element of an SVE builtin type.
/// This is used to represent fixed-length SVE vectors created with the
/// 'arm_sve_vector_bits' type attribute as VectorType.
QualType getSveEltType(const ASTContext &Ctx) const;

/// Types are partitioned into 3 broad categories (C99 6.2.5p1):
/// object types, function types, and incomplete types.

/// Return true if this is an incomplete type.
/// A type that can describe objects, but which lacks information needed to
/// determine its size (e.g. void, or a fwd declared struct). Clients of this
/// routine will need to determine if the size is actually required.
///
/// Def If non-null, and the type refers to some kind of declaration
/// that can be completed (such as a C struct, C++ class, or Objective-C
/// class), will be set to the declaration.
bool isIncompleteType(NamedDecl **Def = nullptr) const;

/// Return true if this is an incomplete or object
/// type, in other words, not a function type.
bool isIncompleteOrObjectType() const {
  return !isFunctionType();
}

/// Determine whether this type is an object type.
bool isObjectType() const {
  // C++ [basic.types]p8:
  //   An object type is a (possibly cv-qualified) type that is not a
  //   function type, not a reference type, and not a void type.
  return !isReferenceType() && !isFunctionType() && !isVoidType();
}

/// Return true if this is a literal type
/// (C++11 [basic.types]p10)
bool isLiteralType(const ASTContext &Ctx) const;

/// Determine if this type is a structural type, per C++20 [temp.param]p7.
bool isStructuralType() const;

/// Test if this type is a standard-layout type.
/// (C++0x [basic.type]p9)
bool isStandardLayoutType() const;

/// Helper methods to distinguish type categories. All type predicates
/// operate on the canonical type, ignoring typedefs and qualifiers.

/// Returns true if the type is a builtin type.
bool isBuiltinType() const;

/// Test for a particular builtin type.
bool isSpecificBuiltinType(unsigned K) const;

/// Test for a type which does not represent an actual type-system type but
/// is instead used as a placeholder for various convenient purposes within
/// Clang.  All such types are BuiltinTypes.
bool isPlaceholderType() const;
const BuiltinType *getAsPlaceholderType() const;

/// Test for a specific placeholder type.
bool isSpecificPlaceholderType(unsigned K) const;

/// Test for a placeholder type other than Overload; see
/// BuiltinType::isNonOverloadPlaceholderType.
bool isNonOverloadPlaceholderType() const;

/// isIntegerType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
bool isEnumeralType() const;

/// Determine whether this type is a scoped enumeration type.
bool isScopedEnumeralType() const;
bool isBooleanType() const;
bool isCharType() const;
bool isWideCharType() const;
bool isChar8Type() const;
bool isChar16Type() const;
bool isChar32Type() const;
bool isAnyCharacterType() const;
bool isIntegralType(const ASTContext &Ctx) const;

/// Determine whether this type is an integral or enumeration type.
bool isIntegralOrEnumerationType() const;

/// Determine whether this type is an integral or unscoped enumeration type.
bool isIntegralOrUnscopedEnumerationType() const;
bool isUnscopedEnumerationType() const;

/// Floating point categories.
bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
/// isComplexType() does *not* include complex integers (a GCC extension).
/// isComplexIntegerType() can be used to test for complex integers.
bool isComplexType() const;      // C99 6.2.5p11 (complex)
bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
bool isBFloat16Type() const;
bool isFloat128Type() const;
bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
bool isVoidType() const;         // C99 6.2.5p19
bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
bool isAggregateType() const;
bool isFundamentalType() const;
bool isCompoundType() const;

// Type Predicates: Check to see if this type is structurally the specified
// type, ignoring typedefs and qualifiers.
bool isFunctionType() const;
bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
bool isPointerType() const;
bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
bool isBlockPointerType() const;
bool isVoidPointerType() const;
bool isReferenceType() const;
bool isLValueReferenceType() const;
bool isRValueReferenceType() const;
bool isObjectPointerType() const;
bool isFunctionPointerType() const;
bool isFunctionReferenceType() const;
bool isMemberPointerType() const;
bool isMemberFunctionPointerType() const;
bool isMemberDataPointerType() const;
bool isArrayType() const;
bool isConstantArrayType() const;
bool isIncompleteArrayType() const;
bool isVariableArrayType() const;
bool isDependentSizedArrayType() const;
bool isRecordType() const;
bool isClassType() const;
bool isStructureType() const;
bool isObjCBoxableRecordType() const;
bool isInterfaceType() const;
bool isStructureOrClassType() const;
bool isUnionType() const;
bool isComplexIntegerType() const;            // GCC _Complex integer type.
bool isVectorType() const;                    // GCC vector type.
bool isExtVectorType() const;                 // Extended vector type.
bool isMatrixType() const;                    // Matrix type.
bool isConstantMatrixType() const;            // Constant matrix type.
bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
bool isObjCObjectPointerType() const;         // pointer to ObjC object
bool isObjCRetainableType() const;            // ObjC object or block pointer
bool isObjCLifetimeType() const;              // (array of)* retainable type
bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
bool isObjCNSObjectType() const;              // __attribute__((NSObject))
bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
// FIXME: change this to 'raw' interface type, so we can used 'interface' type
// for the common case.
bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
bool isObjCQualifiedIdType() const;           // id<foo>
bool isObjCQualifiedClassType() const;        // Class<foo>
bool isObjCObjectOrInterfaceType() const;
bool isObjCIdType() const;                    // id
bool isDecltypeType() const;
/// Was this type written with the special inert-in-ARC __unsafe_unretained
/// qualifier?
///
/// This approximates the answer to the following question: if this
/// translation unit were compiled in ARC, would this type be qualified
/// with __unsafe_unretained?
bool isObjCInertUnsafeUnretainedType() const {
  return hasAttr(attr::ObjCInertUnsafeUnretained);
}

/// Whether the type is Objective-C 'id' or a __kindof type of an
/// object type, e.g., __kindof NSView * or __kindof id
/// <NSCopying>.
///
/// \param bound Will be set to the bound on non-id subtype types,
/// which will be (possibly specialized) Objective-C class type, or
/// null for 'id.
bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
                                const ObjCObjectType *&bound) const;

bool isObjCClassType() const;                 // Class

/// Whether the type is Objective-C 'Class' or a __kindof type of an
/// Class type, e.g., __kindof Class <NSCopying>.
///
/// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
/// here because Objective-C's type system cannot express "a class
/// object for a subclass of NSFoo".
bool isObjCClassOrClassKindOfType() const;

bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
bool isObjCSelType() const;                 // Class
bool isObjCBuiltinType() const;               // 'id' or 'Class'
bool isObjCARCBridgableType() const;
bool isCARCBridgableType() const;
bool isTemplateTypeParmType() const;          // C++ template type parameter
bool isNullPtrType() const;                   // C++11 std::nullptr_t
bool isNothrowT() const;                      // C++   std::nothrow_t
bool isAlignValT() const;                     // C++17 std::align_val_t
bool isStdByteType() const;                   // C++17 std::byte
bool isAtomicType() const;                    // C11 _Atomic()
bool isUndeducedAutoType() const;             // C++11 auto or
                                              // C++14 decltype(auto)
bool isTypedefNameType() const;               // typedef or alias template

2110#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2112#include "clang/Basic/OpenCLImageTypes.def"

bool isImageType() const;                     // Any OpenCL image type

bool isSamplerT() const;                      // OpenCL sampler_t
bool isEventT() const;                        // OpenCL event_t
bool isClkEventT() const;                     // OpenCL clk_event_t
bool isQueueT() const;                        // OpenCL queue_t
bool isReserveIDT() const;                    // OpenCL reserve_id_t

2122#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2124#include "clang/Basic/OpenCLExtensionTypes.def"
// Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
bool isOCLIntelSubgroupAVCType() const;
bool isOCLExtOpaqueType() const;              // Any OpenCL extension type

bool isPipeType() const;                      // OpenCL pipe type
bool isExtIntType() const;                    // Extended Int Type
bool isOpenCLSpecificType() const;            // Any OpenCL specific type

/// Determines if this type, which must satisfy
/// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
/// than implicitly __strong.
bool isObjCARCImplicitlyUnretainedType() const;

/// Check if the type is the CUDA device builtin surface type.
bool isCUDADeviceBuiltinSurfaceType() const;
/// Check if the type is the CUDA device builtin texture type.
bool isCUDADeviceBuiltinTextureType() const;

/// Return the implicit lifetime for this type, which must not be dependent.
Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;

enum ScalarTypeKind {
  STK_CPointer,
  STK_BlockPointer,
  STK_ObjCObjectPointer,
  STK_MemberPointer,
  STK_Bool,
  STK_Integral,
  STK_Floating,
  STK_IntegralComplex,
  STK_FloatingComplex,
  STK_FixedPoint
};

/// Given that this is a scalar type, classify it.
ScalarTypeKind getScalarTypeKind() const;

TypeDependence getDependence() const {
  return static_cast<TypeDependence>(TypeBits.Dependence);
}

/// Whether this type is an error type.
bool containsErrors() const {
  return getDependence() & TypeDependence::Error;
}

/// Whether this type is a dependent type, meaning that its definition
/// somehow depends on a template parameter (C++ [temp.dep.type]).
bool isDependentType() const {
  return getDependence() & TypeDependence::Dependent;
}

/// Determine whether this type is an instantiation-dependent type,
/// meaning that the type involves a template parameter (even if the
/// definition does not actually depend on the type substituted for that
/// template parameter).
bool isInstantiationDependentType() const {
  return getDependence() & TypeDependence::Instantiation;
}

/// Determine whether this type is an undeduced type, meaning that
/// it somehow involves a C++11 'auto' type or similar which has not yet been
/// deduced.
bool isUndeducedType() const;

/// Whether this type is a variably-modified type (C99 6.7.5).
bool isVariablyModifiedType() const {
  return getDependence() & TypeDependence::VariablyModified;
}

/// Whether this type involves a variable-length array type
/// with a definite size.
bool hasSizedVLAType() const;

/// Whether this type is or contains a local or unnamed type.
bool hasUnnamedOrLocalType() const;

bool isOverloadableType() const;

/// Determine wither this type is a C++ elaborated-type-specifier.
bool isElaboratedTypeSpecifier() const;

bool canDecayToPointerType() const;

/// Whether this type is represented natively as a pointer.  This includes
/// pointers, references, block pointers, and Objective-C interface,
/// qualified id, and qualified interface types, as well as nullptr_t.
bool hasPointerRepresentation() const;

/// Whether this type can represent an objective pointer type for the
/// purpose of GC'ability
bool hasObjCPointerRepresentation() const;

/// Determine whether this type has an integer representation
/// of some sort, e.g., it is an integer type or a vector.
bool hasIntegerRepresentation() const;

/// Determine whether this type has an signed integer representation
/// of some sort, e.g., it is an signed integer type or a vector.
bool hasSignedIntegerRepresentation() const;

/// Determine whether this type has an unsigned integer representation
/// of some sort, e.g., it is an unsigned integer type or a vector.
bool hasUnsignedIntegerRepresentation() const;

/// Determine whether this type has a floating-point representation
/// of some sort, e.g., it is a floating-point type or a vector thereof.
bool hasFloatingRepresentation() const;

// Type Checking Functions: Check to see if this type is structurally the
// specified type, ignoring typedefs and qualifiers, and return a pointer to
// the best type we can.
const RecordType *getAsStructureType() const;
/// NOTE: getAs*ArrayType are methods on ASTContext.
const RecordType *getAsUnionType() const;
const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
const ObjCObjectType *getAsObjCInterfaceType() const;

// The following is a convenience method that returns an ObjCObjectPointerType
// for object declared using an interface.
const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;

/// Retrieves the CXXRecordDecl that this type refers to, either
/// because the type is a RecordType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
CXXRecordDecl *getAsCXXRecordDecl() const;

/// Retrieves the RecordDecl this type refers to.
RecordDecl *getAsRecordDecl() const;

/// Retrieves the TagDecl that this type refers to, either
/// because the type is a TagType or because it is the injected-class-name
/// type of a class template or class template partial specialization.
TagDecl *getAsTagDecl() const;

/// If this is a pointer or reference to a RecordType, return the
/// CXXRecordDecl that the type refers to.
///
/// If this is not a pointer or reference, or the type being pointed to does
/// not refer to a CXXRecordDecl, returns NULL.
const CXXRecordDecl *getPointeeCXXRecordDecl() const;

/// Get the DeducedType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
DeducedType *getContainedDeducedType() const;

/// Get the AutoType whose type will be deduced for a variable with
/// an initializer of this type. This looks through declarators like pointer
/// types, but not through decltype or typedefs.
AutoType *getContainedAutoType() const {
  return dyn_cast_or_null<AutoType>(getContainedDeducedType());
}

/// Determine whether this type was written with a leading 'auto'
/// corresponding to a trailing return type (possibly for a nested
/// function type within a pointer to function type or similar).
bool hasAutoForTrailingReturnType() const;

/// Member-template getAs<specific type>'.  Look through sugar for
/// an instance of \<specific type>.   This scheme will eventually
/// replace the specific getAsXXXX methods above.
///
/// There are some specializations of this member template listed
/// immediately following this class.
template <typename T> const T *getAs() const;

/// Member-template getAsAdjusted<specific type>. Look through specific kinds
/// of sugar (parens, attributes, etc) for an instance of \<specific type>.
/// This is used when you need to walk over sugar nodes that represent some
/// kind of type adjustment from a type that was written as a \<specific type>
/// to another type that is still canonically a \<specific type>.
template <typename T> const T *getAsAdjusted() const;

/// A variant of getAs<> for array types which silently discards
/// qualifiers from the outermost type.
const ArrayType *getAsArrayTypeUnsafe() const;

/// Member-template castAs<specific type>.  Look through sugar for
/// the underlying instance of \<specific type>.
///
/// This method has the same relationship to getAs<T> as cast<T> has
/// to dyn_cast<T>; which is to say, the underlying type *must*
/// have the intended type, and this method will never return null.
template <typename T> const T *castAs() const;

/// A variant of castAs<> for array type which silently discards
/// qualifiers from the outermost type.
const ArrayType *castAsArrayTypeUnsafe() const;

/// Determine whether this type had the specified attribute applied to it
/// (looking through top-level type sugar).
bool hasAttr(attr::Kind AK) const;

/// Get the base element type of this type, potentially discarding type
/// qualifiers.  This should never be used when type qualifiers
/// are meaningful.
const Type *getBaseElementTypeUnsafe() const;

/// If this is an array type, return the element type of the array,
/// potentially with type qualifiers missing.
/// This should never be used when type qualifiers are meaningful.
const Type *getArrayElementTypeNoTypeQual() const;

/// If this is a pointer type, return the pointee type.
/// If this is an array type, return the array element type.
/// This should never be used when type qualifiers are meaningful.
const Type *getPointeeOrArrayElementType() const;

/// If this is a pointer, ObjC object pointer, or block
/// pointer, this returns the respective pointee.
QualType getPointeeType() const;

/// Return the specified type with any "sugar" removed from the type,
/// removing any typedefs, typeofs, etc., as well as any qualifiers.
const Type *getUnqualifiedDesugaredType() const;

/// More type predicates useful for type checking/promotion
bool isPromotableIntegerType() const; // C99 6.3.1.1p2

/// Return true if this is an integer type that is
/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
/// or an enum decl which has a signed representation.
bool isSignedIntegerType() const;

/// Return true if this is an integer type that is
/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
/// or an enum decl which has an unsigned representation.
bool isUnsignedIntegerType() const;

/// Determines whether this is an integer type that is signed or an
/// enumeration types whose underlying type is a signed integer type.
bool isSignedIntegerOrEnumerationType() const;

/// Determines whether this is an integer type that is unsigned or an
/// enumeration types whose underlying type is a unsigned integer type.
bool isUnsignedIntegerOrEnumerationType() const;

/// Return true if this is a fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169.
bool isFixedPointType() const;

/// Return true if this is a fixed point or integer type.
bool isFixedPointOrIntegerType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isSaturatedFixedPointType() const;

/// Return true if this is a saturated fixed point type according to
/// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
bool isUnsaturatedFixedPointType() const;

/// Return true if this is a fixed point type that is signed according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isSignedFixedPointType() const;

/// Return true if this is a fixed point type that is unsigned according
/// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
bool isUnsignedFixedPointType() const;

/// Return true if this is not a variable sized type,
/// according to the rules of C99 6.7.5p3.  It is not legal to call this on
/// incomplete types.
bool isConstantSizeType() const;

/// Returns true if this type can be represented by some
/// set of type specifiers.
bool isSpecifierType() const;

/// Determine the linkage of this type.
Linkage getLinkage() const;

/// Determine the visibility of this type.
Visibility getVisibility() const {
  return getLinkageAndVisibility().getVisibility();
}

/// Return true if the visibility was explicitly set is the code.
bool isVisibilityExplicit() const {
  return getLinkageAndVisibility().isVisibilityExplicit();
}

/// Determine the linkage and visibility of this type.
LinkageInfo getLinkageAndVisibility() const;

/// True if the computed linkage is valid. Used for consistency
/// checking. Should always return true.
bool isLinkageValid() const;

/// Determine the nullability of the given type.
///
/// Note that nullability is only captured as sugar within the type
/// system, not as part of the canonical type, so nullability will
/// be lost by canonicalization and desugaring.
Optional<NullabilityKind> getNullability(const ASTContext &context) const;

/// Determine whether the given type can have a nullability
/// specifier applied to it, i.e., if it is any kind of pointer type.
///
/// \param ResultIfUnknown The value to return if we don't yet know whether
///        this type can have nullability because it is dependent.
bool canHaveNullability(bool ResultIfUnknown = true) const;

/// Retrieve the set of substitutions required when accessing a member
/// of the Objective-C receiver type that is declared in the given context.
///
/// \c *this is the type of the object we're operating on, e.g., the
/// receiver for a message send or the base of a property access, and is
/// expected to be of some object or object pointer type.
///
/// \param dc The declaration context for which we are building up a
/// substitution mapping, which should be an Objective-C class, extension,
/// category, or method within.
///
/// \returns an array of type arguments that can be substituted for
/// the type parameters of the given declaration context in any type described
/// within that context, or an empty optional to indicate that no
/// substitution is required.
Optional<ArrayRef<QualType>>
getObjCSubstitutions(const DeclContext *dc) const;

/// Determines if this is an ObjC interface type that may accept type
/// parameters.
bool acceptsObjCTypeParams() const;

const char *getTypeClassName() const;

QualType getCanonicalTypeInternal() const {
  return CanonicalType;
}

CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
void dump() const;
void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2463};

2465/// This will check for a TypedefType by removing any existing sugar
2466/// until it reaches a TypedefType or a non-sugared type.
2467template <> const TypedefType *Type::getAs() const;

2469/// This will check for a TemplateSpecializationType by removing any
2470/// existing sugar until it reaches a TemplateSpecializationType or a
2471/// non-sugared type.
2472template <> const TemplateSpecializationType *Type::getAs() const;

2474/// This will check for an AttributedType by removing any existing sugar
2475/// until it reaches an AttributedType or a non-sugared type.
2476template <> const AttributedType *Type::getAs() const;

2478// We can do canonical leaf types faster, because we don't have to
2479// worry about preserving child type decoration.
2480#define TYPE(Class, Base)
2481#define LEAF_TYPE(Class) \
2482template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2484} \
2485template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2487}
2488#include "clang/AST/TypeNodes.inc"

2490/// This class is used for builtin types like 'int'.  Builtin
2491/// types are always canonical and have a literal name field.
2492class BuiltinType : public Type {
2493public:
enum Kind {
2495// OpenCL image types
2496#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2497#include "clang/Basic/OpenCLImageTypes.def"
2498// OpenCL extension types
2499#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2500#include "clang/Basic/OpenCLExtensionTypes.def"
2501// SVE Types
2502#define SVE_TYPE(Name, Id, SingletonId) Id,
2503#include "clang/Basic/AArch64SVEACLETypes.def"
2504// PPC MMA Types
2505#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2506#include "clang/Basic/PPCTypes.def"
2507// RVV Types
2508#define RVV_TYPE(Name, Id, SingletonId) Id,
2509#include "clang/Basic/RISCVVTypes.def"
2510// All other builtin types
2511#define BUILTIN_TYPE(Id, SingletonId) Id,
2512#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2513#include "clang/AST/BuiltinTypes.def"
};

2516private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(),
           K == Dependent ? TypeDependence::DependentInstantiation
                          : TypeDependence::None) {
  BuiltinTypeBits.Kind = K;
}

2526public:
Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
StringRef getName(const PrintingPolicy &Policy) const;

const char *getNameAsCString(const PrintingPolicy &Policy) const {
  // The StringRef is null-terminated.
  StringRef str = getName(Policy);
  assert(!str.empty() && str.data()[str.size()] == '\0')(static_cast<void> (0));
  return str.data();
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

bool isInteger() const {
  return getKind() >= Bool && getKind() <= Int128;
}

bool isSignedInteger() const {
  return getKind() >= Char_S && getKind() <= Int128;
}

bool isUnsignedInteger() const {
  return getKind() >= Bool && getKind() <= UInt128;
}

bool isFloatingPoint() const {
  return getKind() >= Half && getKind() <= Float128;
}

/// Determines whether the given kind corresponds to a placeholder type.
static bool isPlaceholderTypeKind(Kind K) {
  return K >= Overload;
}

/// Determines whether this type is a placeholder type, i.e. a type
/// which cannot appear in arbitrary positions in a fully-formed
/// expression.
bool isPlaceholderType() const {
  return isPlaceholderTypeKind(getKind());
}

/// Determines whether this type is a placeholder type other than
/// Overload.  Most placeholder types require only syntactic
/// information about their context in order to be resolved (e.g.
/// whether it is a call expression), which means they can (and
/// should) be resolved in an earlier "phase" of analysis.
/// Overload expressions sometimes pick up further information
/// from their context, like whether the context expects a
/// specific function-pointer type, and so frequently need
/// special treatment.
bool isNonOverloadPlaceholderType() const {
  return getKind() > Overload;
}

static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2582};

2584/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2585/// types (_Complex float etc) as well as the GCC integer complex extensions.
2586class ComplexType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;

ComplexType(QualType Element, QualType CanonicalPtr)
    : Type(Complex, CanonicalPtr, Element->getDependence()),
      ElementType(Element) {}

2595public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
  ID.AddPointer(Element.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2610};

2612/// Sugar for parentheses used when specifying types.
2613class ParenType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType Inner;

ParenType(QualType InnerType, QualType CanonType)
    : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}

2621public:
QualType getInnerType() const { return Inner; }

bool isSugared() const { return true; }
QualType desugar() const { return getInnerType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getInnerType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
  Inner.Profile(ID);
}

static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2636};

2638/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2639class PointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

PointerType(QualType Pointee, QualType CanonicalPtr)
    : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
      PointeeType(Pointee) {}

2648public:
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2663};

2665/// Represents a type which was implicitly adjusted by the semantic
2666/// engine for arbitrary reasons.  For example, array and function types can
2667/// decay, and function types can have their calling conventions adjusted.
2668class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2672protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2680public:
QualType getOriginalType() const { return OriginalTy; }
QualType getAdjustedType() const { return AdjustedTy; }

bool isSugared() const { return true; }
QualType desugar() const { return AdjustedTy; }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, OriginalTy, AdjustedTy);
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
  ID.AddPointer(Orig.getAsOpaquePtr());
  ID.AddPointer(New.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
}
2699};

2701/// Represents a pointer type decayed from an array or function type.
2702class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2708public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2714};

2716/// Pointer to a block type.
2717/// This type is to represent types syntactically represented as
2718/// "void (^)(int)", etc. Pointee is required to always be a function type.
2719class BlockPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

// Block is some kind of pointer type
QualType PointeeType;

BlockPointerType(QualType Pointee, QualType CanonicalCls)
    : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
      PointeeType(Pointee) {}

2729public:
// Get the pointee type. Pointee is required to always be a function type.
QualType getPointeeType() const { return PointeeType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
    Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
    ID.AddPointer(Pointee.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == BlockPointer;
}
2747};

2749/// Base for LValueReferenceType and RValueReferenceType
2750class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2753protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->getDependence()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2762public:
bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }

QualType getPointeeTypeAsWritten() const { return PointeeType; }

QualType getPointeeType() const {
  // FIXME: this might strip inner qualifiers; okay?
  const ReferenceType *T = this;
  while (T->isInnerRef())
    T = T->PointeeType->castAs<ReferenceType>();
  return T->PointeeType;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, PointeeType, isSpelledAsLValue());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Referencee,
                    bool SpelledAsLValue) {
  ID.AddPointer(Referencee.getAsOpaquePtr());
  ID.AddBoolean(SpelledAsLValue);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference ||
         T->getTypeClass() == RValueReference;
}
2791};

2793/// An lvalue reference type, per C++11 [dcl.ref].
2794class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2802public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2809};

2811/// An rvalue reference type, per C++11 [dcl.ref].
2812class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2818public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2825};

2827/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2828///
2829/// This includes both pointers to data members and pointer to member functions.
2830class MemberPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

/// The class of which the pointee is a member. Must ultimately be a
/// RecordType, but could be a typedef or a template parameter too.
const Type *Class;

MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
    : Type(MemberPointer, CanonicalPtr,
           (Cls->getDependence() & ~TypeDependence::VariablyModified) |
               Pointee->getDependence()),
      PointeeType(Pointee), Class(Cls) {}

2845public:
QualType getPointeeType() const { return PointeeType; }

/// Returns true if the member type (i.e. the pointee type) is a
/// function type rather than a data-member type.
bool isMemberFunctionPointer() const {
  return PointeeType->isFunctionProtoType();
}

/// Returns true if the member type (i.e. the pointee type) is a
/// data type rather than a function type.
bool isMemberDataPointer() const {
  return !PointeeType->isFunctionProtoType();
}

const Type *getClass() const { return Class; }
CXXRecordDecl *getMostRecentCXXRecordDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType(), getClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
                    const Type *Class) {
  ID.AddPointer(Pointee.getAsOpaquePtr());
  ID.AddPointer(Class);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == MemberPointer;
}
2879};

2881/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2882class ArrayType : public Type, public llvm::FoldingSetNode {
2883public:
/// Capture whether this is a normal array (e.g. int X[4])
/// an array with a static size (e.g. int X[static 4]), or an array
/// with a star size (e.g. int X[*]).
/// 'static' is only allowed on function parameters.
enum ArraySizeModifier {
  Normal, Static, Star
};

2892private:
/// The element type of the array.
QualType ElementType;

2896protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2902public:
QualType getElementType() const { return ElementType; }

ArraySizeModifier getSizeModifier() const {
  return ArraySizeModifier(ArrayTypeBits.SizeModifier);
}

Qualifiers getIndexTypeQualifiers() const {
  return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
}

unsigned getIndexTypeCVRQualifiers() const {
  return ArrayTypeBits.IndexTypeQuals;
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray ||
         T->getTypeClass() == VariableArray ||
         T->getTypeClass() == IncompleteArray ||
         T->getTypeClass() == DependentSizedArray;
}
2923};

2925/// Represents the canonical version of C arrays with a specified constant size.
2926/// For example, the canonical type for 'int A[4 + 4*100]' is a
2927/// ConstantArrayType where the element type is 'int' and the size is 404.
2928class ConstantArrayType final
  : public ArrayType,
    private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

llvm::APInt Size; // Allows us to unique the type.

ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
                  const Expr *sz, ArraySizeModifier sm, unsigned tq)
    : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
  ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
  if (ConstantArrayTypeBits.HasStoredSizeExpr) {
    assert(!can.isNull() && "canonical constant array should not have size")(static_cast<void> (0));
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2950public:
const llvm::APInt &getSize() const { return Size; }
const Expr *getSizeExpr() const {
  return ConstantArrayTypeBits.HasStoredSizeExpr
             ? *getTrailingObjects<const Expr *>()
             : nullptr;
}
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Determine the number of bits required to address a member of
// an array with the given element type and number of elements.
static unsigned getNumAddressingBits(const ASTContext &Context,
                                     QualType ElementType,
                                     const llvm::APInt &NumElements);

/// Determine the maximum number of active bits that an array's size
/// can require, which limits the maximum size of the array.
static unsigned getMaxSizeBits(const ASTContext &Context);

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
          getSizeModifier(), getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                    QualType ET, const llvm::APInt &ArraySize,
                    const Expr *SizeExpr, ArraySizeModifier SizeMod,
                    unsigned TypeQuals);

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantArray;
}
2983};

2985/// Represents a C array with an unspecified size.  For example 'int A[]' has
2986/// an IncompleteArrayType where the element type is 'int' and the size is
2987/// unspecified.
2988class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2995public:
friend class StmtIteratorBase;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == IncompleteArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getSizeModifier(),
          getIndexTypeCVRQualifiers());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
                    ArraySizeModifier SizeMod, unsigned TypeQuals) {
  ID.AddPointer(ET.getAsOpaquePtr());
  ID.AddInteger(SizeMod);
  ID.AddInteger(TypeQuals);
}
3016};

3018/// Represents a C array with a specified size that is not an
3019/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3020/// Since the size expression is an arbitrary expression, we store it as such.
3021///
3022/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3023/// should not be: two lexically equivalent variable array types could mean
3024/// different things, for example, these variables do not have the same type
3025/// dynamically:
3026///
3027/// void foo(int x) {
3028///   int Y[x];
3029///   ++x;
3030///   int Z[x];
3031/// }
3032class VariableArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

/// An assignment-expression. VLA's are only permitted within
/// a function block.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

VariableArrayType(QualType et, QualType can, Expr *e,
                  ArraySizeModifier sm, unsigned tq,
                  SourceRange brackets)
    : ArrayType(VariableArray, et, can, sm, tq, e),
      SizeExpr((Stmt*) e), Brackets(brackets) {}

3048public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == VariableArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  llvm_unreachable("Cannot unique VariableArrayTypes.")__builtin_unreachable();
}
3071};

3073/// Represents an array type in C++ whose size is a value-dependent expression.
3074///
3075/// For example:
3076/// \code
3077/// template<typename T, int Size>
3078/// class array {
3079///   T data[Size];
3080/// };
3081/// \endcode
3082///
3083/// For these types, we won't actually know what the array bound is
3084/// until template instantiation occurs, at which point this will
3085/// become either a ConstantArrayType or a VariableArrayType.
3086class DependentSizedArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

const ASTContext &Context;

/// An assignment expression that will instantiate to the
/// size of the array.
///
/// The expression itself might be null, in which case the array
/// type will have its size deduced from an initializer.
Stmt *SizeExpr;

/// The range spanned by the left and right array brackets.
SourceRange Brackets;

DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
                        Expr *e, ArraySizeModifier sm, unsigned tq,
                        SourceRange brackets);

3105public:
friend class StmtIteratorBase;

Expr *getSizeExpr() const {
  // We use C-style casts instead of cast<> here because we do not wish
  // to have a dependency of Type.h on Stmt.h/Expr.h.
  return (Expr*) SizeExpr;
}

SourceRange getBracketsRange() const { return Brackets; }
SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedArray;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(),
          getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ET, ArraySizeModifier SizeMod,
                    unsigned TypeQuals, Expr *E);
3133};

3135/// Represents an extended address space qualifier where the input address space
3136/// value is dependent. Non-dependent address spaces are not represented with a
3137/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3138///
3139/// For example:
3140/// \code
3141/// template<typename T, int AddrSpace>
3142/// class AddressSpace {
3143///   typedef T __attribute__((address_space(AddrSpace))) type;
3144/// }
3145/// \endcode
3146class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *AddrSpaceExpr;
QualType PointeeType;
SourceLocation loc;

DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
                          QualType can, Expr *AddrSpaceExpr,
                          SourceLocation loc);

3158public:
Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
QualType getPointeeType() const { return PointeeType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentAddressSpace;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType PointeeType, Expr *AddrSpaceExpr);
3176};

3178/// Represents an extended vector type where either the type or size is
3179/// dependent.
3180///
3181/// For example:
3182/// \code
3183/// template<typename T, int Size>
3184/// class vector {
3185///   typedef T __attribute__((ext_vector_type(Size))) type;
3186/// }
3187/// \endcode
3188class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
Expr *SizeExpr;

/// The element type of the array.
QualType ElementType;

SourceLocation loc;

DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
                            QualType can, Expr *SizeExpr, SourceLocation loc);

3202public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return loc; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedExtVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *SizeExpr);
3220};


3223/// Represents a GCC generic vector type. This type is created using
3224/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3225/// bytes; or from an Altivec __vector or vector declaration.
3226/// Since the constructor takes the number of vector elements, the
3227/// client is responsible for converting the size into the number of elements.
3228class VectorType : public Type, public llvm::FoldingSetNode {
3229public:
enum VectorKind {
  /// not a target-specific vector type
  GenericVector,

  /// is AltiVec vector
  AltiVecVector,

  /// is AltiVec 'vector Pixel'
  AltiVecPixel,

  /// is AltiVec 'vector bool ...'
  AltiVecBool,

  /// is ARM Neon vector
  NeonVector,

  /// is ARM Neon polynomial vector
  NeonPolyVector,

  /// is AArch64 SVE fixed-length data vector
  SveFixedLengthDataVector,

  /// is AArch64 SVE fixed-length predicate vector
  SveFixedLengthPredicateVector
};

3256protected:
friend class ASTContext; // ASTContext creates these.

/// The element type of the vector.
QualType ElementType;

VectorType(QualType vecType, unsigned nElements, QualType canonType,
           VectorKind vecKind);

VectorType(TypeClass tc, QualType vecType, unsigned nElements,
           QualType canonType, VectorKind vecKind);

3268public:
QualType getElementType() const { return ElementType; }
unsigned getNumElements() const { return VectorTypeBits.NumElements; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

VectorKind getVectorKind() const {
  return VectorKind(VectorTypeBits.VecKind);
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumElements(),
          getTypeClass(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumElements, TypeClass TypeClass,
                    VectorKind VecKind) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumElements);
  ID.AddInteger(TypeClass);
  ID.AddInteger(VecKind);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
}
3296};

3298/// Represents a vector type where either the type or size is dependent.
3299////
3300/// For example:
3301/// \code
3302/// template<typename T, int Size>
3303/// class vector {
3304///   typedef T __attribute__((vector_size(Size))) type;
3305/// }
3306/// \endcode
3307class DependentVectorType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

const ASTContext &Context;
QualType ElementType;
Expr *SizeExpr;
SourceLocation Loc;

DependentVectorType(const ASTContext &Context, QualType ElementType,
                         QualType CanonType, Expr *SizeExpr,
                         SourceLocation Loc, VectorType::VectorKind vecKind);

3319public:
Expr *getSizeExpr() const { return SizeExpr; }
QualType getElementType() const { return ElementType; }
SourceLocation getAttributeLoc() const { return Loc; }
VectorType::VectorKind getVectorKind() const {
  return VectorType::VectorKind(VectorTypeBits.VecKind);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentVector;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, const Expr *SizeExpr,
                    VectorType::VectorKind VecKind);
3341};

3343/// ExtVectorType - Extended vector type. This type is created using
3344/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3345/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3346/// class enables syntactic extensions, like Vector Components for accessing
3347/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3348/// Shading Language).
3349class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3355public:
static int getPointAccessorIdx(char c) {
  switch (c) {
  default: return -1;
  case 'x': case 'r': return 0;
  case 'y': case 'g': return 1;
  case 'z': case 'b': return 2;
  case 'w': case 'a': return 3;
  }
}

static int getNumericAccessorIdx(char c) {
  switch (c) {
    default: return -1;
    case '0': return 0;
    case '1': return 1;
    case '2': return 2;
    case '3': return 3;
    case '4': return 4;
    case '5': return 5;
    case '6': return 6;
    case '7': return 7;
    case '8': return 8;
    case '9': return 9;
    case 'A':
    case 'a': return 10;
    case 'B':
    case 'b': return 11;
    case 'C':
    case 'c': return 12;
    case 'D':
    case 'd': return 13;
    case 'E':
    case 'e': return 14;
    case 'F':
    case 'f': return 15;
  }
}

static int getAccessorIdx(char c, bool isNumericAccessor) {
  if (isNumericAccessor)
    return getNumericAccessorIdx(c);
  else
    return getPointAccessorIdx(c);
}

bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
  if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
    return unsigned(idx-1) < getNumElements();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ExtVector;
}
3413};

3415/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3416/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3417/// number of rows and "columns" specifies the number of columns.
3418class MatrixType : public Type, public llvm::FoldingSetNode {
3419protected:
friend class ASTContext;

/// The element type of the matrix.
QualType ElementType;

MatrixType(QualType ElementTy, QualType CanonElementTy);

MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
           const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);

3430public:
/// Returns type of the elements being stored in the matrix
QualType getElementType() const { return ElementType; }

/// Valid elements types are the following:
/// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
///   and _Bool
/// * the standard floating types float or double
/// * a half-precision floating point type, if one is supported on the target
static bool isValidElementType(QualType T) {
  return T->isDependentType() ||
         (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix ||
         T->getTypeClass() == DependentSizedMatrix;
}
3451};

3453/// Represents a concrete matrix type with constant number of rows and columns
3454class ConstantMatrixType final : public MatrixType {
3455protected:
friend class ASTContext;

/// Number of rows and columns.
unsigned NumRows;
unsigned NumColumns;

static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;

ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
                   unsigned NColumns, QualType CanonElementType);

3470public:
/// Returns the number of rows in the matrix.
unsigned getNumRows() const { return NumRows; }

/// Returns the number of columns in the matrix.
unsigned getNumColumns() const { return NumColumns; }

/// Returns the number of elements required to embed the matrix into a vector.
unsigned getNumElementsFlattened() const {
  return getNumRows() * getNumColumns();
}

/// Returns true if \p NumElements is a valid matrix dimension.
static constexpr bool isDimensionValid(size_t NumElements) {
  return NumElements > 0 && NumElements <= MaxElementsPerDimension;
}

/// Returns the maximum number of elements per dimension.
static constexpr unsigned getMaxElementsPerDimension() {
  return MaxElementsPerDimension;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), getNumRows(), getNumColumns(),
          getTypeClass());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
                    unsigned NumRows, unsigned NumColumns,
                    TypeClass TypeClass) {
  ID.AddPointer(ElementType.getAsOpaquePtr());
  ID.AddInteger(NumRows);
  ID.AddInteger(NumColumns);
  ID.AddInteger(TypeClass);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ConstantMatrix;
}
3509};

3511/// Represents a matrix type where the type and the number of rows and columns
3512/// is dependent on a template.
3513class DependentSizedMatrixType final : public MatrixType {
friend class ASTContext;

const ASTContext &Context;
Expr *RowExpr;
Expr *ColumnExpr;

SourceLocation loc;

DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
                         QualType CanonicalType, Expr *RowExpr,
                         Expr *ColumnExpr, SourceLocation loc);

3526public:
Expr *getRowExpr() const { return RowExpr; }
Expr *getColumnExpr() const { return ColumnExpr; }
SourceLocation getAttributeLoc() const { return loc; }

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentSizedMatrix;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3541};

3543/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3544/// class of FunctionNoProtoType and FunctionProtoType.
3545class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3549public:
/// Interesting information about a specific parameter that can't simply
/// be reflected in parameter's type. This is only used by FunctionProtoType
/// but is in FunctionType to make this class available during the
/// specification of the bases of FunctionProtoType.
///
/// It makes sense to model language features this way when there's some
/// sort of parameter-specific override (such as an attribute) that
/// affects how the function is called.  For example, the ARC ns_consumed
/// attribute changes whether a parameter is passed at +0 (the default)
/// or +1 (ns_consumed).  This must be reflected in the function type,
/// but isn't really a change to the parameter type.
///
/// One serious disadvantage of modelling language features this way is
/// that they generally do not work with language features that attempt
/// to destructure types.  For example, template argument deduction will
/// not be able to match a parameter declared as
///   T (*)(U)
/// against an argument of type
///   void (*)(__attribute__((ns_consumed)) id)
/// because the substitution of T=void, U=id into the former will
/// not produce the latter.
class ExtParameterInfo {
  enum {
    ABIMask = 0x0F,
    IsConsumed = 0x10,
    HasPassObjSize = 0x20,
    IsNoEscape = 0x40,
  };
  unsigned char Data = 0;

public:
  ExtParameterInfo() = default;

  /// Return the ABI treatment of this parameter.
  ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
  ExtParameterInfo withABI(ParameterABI kind) const {
    ExtParameterInfo copy = *this;
    copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
    return copy;
  }

  /// Is this parameter considered "consumed" by Objective-C ARC?
  /// Consumed parameters must have retainable object type.
  bool isConsumed() const { return (Data & IsConsumed); }
  ExtParameterInfo withIsConsumed(bool consumed) const {
    ExtParameterInfo copy = *this;
    if (consumed)
      copy.Data |= IsConsumed;
    else
      copy.Data &= ~IsConsumed;
    return copy;
  }

  bool hasPassObjectSize() const { return Data & HasPassObjSize; }
  ExtParameterInfo withHasPassObjectSize() const {
    ExtParameterInfo Copy = *this;
    Copy.Data |= HasPassObjSize;
    return Copy;
  }

  bool isNoEscape() const { return Data & IsNoEscape; }
  ExtParameterInfo withIsNoEscape(bool NoEscape) const {
    ExtParameterInfo Copy = *this;
    if (NoEscape)
      Copy.Data |= IsNoEscape;
    else
      Copy.Data &= ~IsNoEscape;
    return Copy;
  }

  unsigned char getOpaqueValue() const { return Data; }
  static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
    ExtParameterInfo result;
    result.Data = data;
    return result;
  }

  friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data == rhs.Data;
  }

  friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
    return lhs.Data != rhs.Data;
  }
};

/// A class which abstracts out some details necessary for
/// making a call.
///
/// It is not actually used directly for storing this information in
/// a FunctionType, although FunctionType does currently use the
/// same bit-pattern.
///
// If you add a field (say Foo), other than the obvious places (both,
// constructors, compile failures), what you need to update is
// * Operator==
// * getFoo
// * withFoo
// * functionType. Add Foo, getFoo.
// * ASTContext::getFooType
// * ASTContext::mergeFunctionTypes
// * FunctionNoProtoType::Profile
// * FunctionProtoType::Profile
// * TypePrinter::PrintFunctionProto
// * AST read and write
// * Codegen
class ExtInfo {
  friend class FunctionType;

  // Feel free to rearrange or add bits, but if you go over 16, you'll need to
  // adjust the Bits field below, and if you add bits, you'll need to adjust
  // Type::FunctionTypeBitfields::ExtInfo as well.

  // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
  // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
  //
  // regparm is either 0 (no regparm attribute) or the regparm value+1.
  enum { CallConvMask = 0x1F };
  enum { NoReturnMask = 0x20 };
  enum { ProducesResultMask = 0x40 };
  enum { NoCallerSavedRegsMask = 0x80 };
  enum {
    RegParmMask =  0x700,
    RegParmOffset = 8
  };
  enum { NoCfCheckMask = 0x800 };
  enum { CmseNSCallMask = 0x1000 };
  uint16_t Bits = CC_C;

  ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}

public:
  // Constructor with no defaults. Use this when you know that you
  // have all the elements (when reading an AST file for example).
  ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
          bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
          bool cmseNSCall) {
    assert((!hasRegParm || regParm < 7) && "Invalid regparm value")(static_cast<void> (0));
    Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
           (producesResult ? ProducesResultMask : 0) |
           (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
           (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
           (NoCfCheck ? NoCfCheckMask : 0) |
           (cmseNSCall ? CmseNSCallMask : 0);
  }

  // Constructor with all defaults. Use when for example creating a
  // function known to use defaults.
  ExtInfo() = default;

  // Constructor with just the calling convention, which is an important part
  // of the canonical type.
  ExtInfo(CallingConv CC) : Bits(CC) {}

  bool getNoReturn() const { return Bits & NoReturnMask; }
  bool getProducesResult() const { return Bits & ProducesResultMask; }
  bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
  bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
  bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
  bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }

  unsigned getRegParm() const {
    unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
    if (RegParm > 0)
      --RegParm;
    return RegParm;
  }

  CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }

  bool operator==(ExtInfo Other) const {
    return Bits == Other.Bits;
  }
  bool operator!=(ExtInfo Other) const {
    return Bits != Other.Bits;
  }

  // Note that we don't have setters. That is by design, use
  // the following with methods instead of mutating these objects.

  ExtInfo withNoReturn(bool noReturn) const {
    if (noReturn)
      return ExtInfo(Bits | NoReturnMask);
    else
      return ExtInfo(Bits & ~NoReturnMask);
  }

  ExtInfo withProducesResult(bool producesResult) const {
    if (producesResult)
      return ExtInfo(Bits | ProducesResultMask);
    else
      return ExtInfo(Bits & ~ProducesResultMask);
  }

  ExtInfo withCmseNSCall(bool cmseNSCall) const {
    if (cmseNSCall)
      return ExtInfo(Bits | CmseNSCallMask);
    else
      return ExtInfo(Bits & ~CmseNSCallMask);
  }

  ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
    if (noCallerSavedRegs)
      return ExtInfo(Bits | NoCallerSavedRegsMask);
    else
      return ExtInfo(Bits & ~NoCallerSavedRegsMask);
  }

  ExtInfo withNoCfCheck(bool noCfCheck) const {
    if (noCfCheck)
      return ExtInfo(Bits | NoCfCheckMask);
    else
      return ExtInfo(Bits & ~NoCfCheckMask);
  }

  ExtInfo withRegParm(unsigned RegParm) const {
    assert(RegParm < 7 && "Invalid regparm value")(static_cast<void> (0));
    return ExtInfo((Bits & ~RegParmMask) |
                   ((RegParm + 1) << RegParmOffset));
  }

  ExtInfo withCallingConv(CallingConv cc) const {
    return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
  }

  void Profile(llvm::FoldingSetNodeID &ID) const {
    ID.AddInteger(Bits);
  }
};

/// A simple holder for a QualType representing a type in an
/// exception specification. Unfortunately needed by FunctionProtoType
/// because TrailingObjects cannot handle repeated types.
struct ExceptionType { QualType Type; };

/// A simple holder for various uncommon bits which do not fit in
/// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
/// alignment of subsequent objects in TrailingObjects. You must update
/// hasExtraBitfields in FunctionProtoType after adding extra data here.
struct alignas(void *) FunctionTypeExtraBitfields {
  /// The number of types in the exception specification.
  /// A whole unsigned is not needed here and according to
  /// [implimits] 8 bits would be enough here.
  unsigned NumExceptionType;
};

3796protected:
FunctionType(TypeClass tc, QualType res, QualType Canonical,
             TypeDependence Dependence, ExtInfo Info)
    : Type(tc, Canonical, Dependence), ResultType(res) {
  FunctionTypeBits.ExtInfo = Info.Bits;
}

Qualifiers getFastTypeQuals() const {
  return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
}

3807public:
QualType getReturnType() const { return ResultType; }

bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
unsigned getRegParmType() const { return getExtInfo().getRegParm(); }

/// Determine whether this function type includes the GNU noreturn
/// attribute. The C++11 [[noreturn]] attribute does not affect the function
/// type.
bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }

bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
CallingConv getCallConv() const { return getExtInfo().getCC(); }
ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }

static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
              "Const, volatile and restrict are assumed to be a subset of "
              "the fast qualifiers.");

bool isConst() const { return getFastTypeQuals().hasConst(); }
bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }

/// Determine the type of an expression that calls a function of
/// this type.
QualType getCallResultType(const ASTContext &Context) const {
  return getReturnType().getNonLValueExprType(Context);
}

static StringRef getNameForCallConv(CallingConv CC);

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto ||
         T->getTypeClass() == FunctionProto;
}
3842};

3844/// Represents a K&R-style 'int foo()' function, which has
3845/// no information available about its arguments.
3846class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
    : FunctionType(FunctionNoProto, Result, Canonical,
                   Result->getDependence() &
                       ~(TypeDependence::DependentInstantiation |
                         TypeDependence::UnexpandedPack),
                   Info) {}

3856public:
// No additional state past what FunctionType provides.

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReturnType(), getExtInfo());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
                    ExtInfo Info) {
  Info.Profile(ID);
  ID.AddPointer(ResultType.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionNoProto;
}
3875};

3877/// Represents a prototype with parameter type info, e.g.
3878/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3879/// parameters, not as having a single void parameter. Such a type can have
3880/// an exception specification, but this specification is not part of the
3881/// canonical type. FunctionProtoType has several trailing objects, some of
3882/// which optional. For more information about the trailing objects see
3883/// the first comment inside FunctionProtoType.
3884class FunctionProtoType final
  : public FunctionType,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<
        FunctionProtoType, QualType, SourceLocation,
        FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
        Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
friend class ASTContext; // ASTContext creates these.
friend TrailingObjects;

// FunctionProtoType is followed by several trailing objects, some of
// which optional. They are in order:
//
// * An array of getNumParams() QualType holding the parameter types.
//   Always present. Note that for the vast majority of FunctionProtoType,
//   these will be the only trailing objects.
//
// * Optionally if the function is variadic, the SourceLocation of the
//   ellipsis.
//
// * Optionally if some extra data is stored in FunctionTypeExtraBitfields
//   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
//   a single FunctionTypeExtraBitfields. Present if and only if
//   hasExtraBitfields() is true.
//
// * Optionally exactly one of:
//   * an array of getNumExceptions() ExceptionType,
//   * a single Expr *,
//   * a pair of FunctionDecl *,
//   * a single FunctionDecl *
//   used to store information about the various types of exception
//   specification. See getExceptionSpecSize for the details.
//
// * Optionally an array of getNumParams() ExtParameterInfo holding
//   an ExtParameterInfo for each of the parameters. Present if and
//   only if hasExtParameterInfos() is true.
//
// * Optionally a Qualifiers object to represent extra qualifiers that can't
//   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
//   if hasExtQualifiers() is true.
//
// The optional FunctionTypeExtraBitfields has to be before the data
// related to the exception specification since it contains the number
// of exception types.
//
// We put the ExtParameterInfos last.  If all were equal, it would make
// more sense to put these before the exception specification, because
// it's much easier to skip past them compared to the elaborate switch
// required to skip the exception specification.  However, all is not
// equal; ExtParameterInfos are used to model very uncommon features,
// and it's better not to burden the more common paths.

3936public:
/// Holds information about the various types of exception specification.
/// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
/// used to group together the various bits of information about the
/// exception specification.
struct ExceptionSpecInfo {
  /// The kind of exception specification this is.
  ExceptionSpecificationType Type = EST_None;

  /// Explicitly-specified list of exception types.
  ArrayRef<QualType> Exceptions;

  /// Noexcept expression, if this is a computed noexcept specification.
  Expr *NoexceptExpr = nullptr;

  /// The function whose exception specification this is, for
  /// EST_Unevaluated and EST_Uninstantiated.
  FunctionDecl *SourceDecl = nullptr;

  /// The function template whose exception specification this is instantiated
  /// from, for EST_Uninstantiated.
  FunctionDecl *SourceTemplate = nullptr;

  ExceptionSpecInfo() = default;

  ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
};

/// Extra information about a function prototype. ExtProtoInfo is not
/// stored as such in FunctionProtoType but is used to group together
/// the various bits of extra information about a function prototype.
struct ExtProtoInfo {
  FunctionType::ExtInfo ExtInfo;
  bool Variadic : 1;
  bool HasTrailingReturn : 1;
  Qualifiers TypeQuals;
  RefQualifierKind RefQualifier = RQ_None;
  ExceptionSpecInfo ExceptionSpec;
  const ExtParameterInfo *ExtParameterInfos = nullptr;
  SourceLocation EllipsisLoc;

  ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo(CallingConv CC)
      : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}

  ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
    ExtProtoInfo Result(*this);
    Result.ExceptionSpec = ESI;
    return Result;
  }
};

3989private:
unsigned numTrailingObjects(OverloadToken<QualType>) const {
  return getNumParams();
}

unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return isVariadic();
}

unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
  return hasExtraBitfields();
}

unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
  return getExceptionSpecSize().NumExceptionType;
}

unsigned numTrailingObjects(OverloadToken<Expr *>) const {
  return getExceptionSpecSize().NumExprPtr;
}

unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
  return getExceptionSpecSize().NumFunctionDeclPtr;
}

unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
  return hasExtParameterInfos() ? getNumParams() : 0;
}

/// Determine whether there are any argument types that
/// contain an unexpanded parameter pack.
static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
                                               unsigned numArgs) {
  for (unsigned Idx = 0; Idx < numArgs; ++Idx)
    if (ArgArray[Idx]->containsUnexpandedParameterPack())
      return true;

  return false;
}

FunctionProtoType(QualType result, ArrayRef<QualType> params,
                  QualType canonical, const ExtProtoInfo &epi);

/// This struct is returned by getExceptionSpecSize and is used to
/// translate an ExceptionSpecificationType to the number and kind
/// of trailing objects related to the exception specification.
struct ExceptionSpecSizeHolder {
  unsigned NumExceptionType;
  unsigned NumExprPtr;
  unsigned NumFunctionDeclPtr;
};

/// Return the number and kind of trailing objects
/// related to the exception specification.
static ExceptionSpecSizeHolder
getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
  switch (EST) {
  case EST_None:
  case EST_DynamicNone:
  case EST_MSAny:
  case EST_BasicNoexcept:
  case EST_Unparsed:
  case EST_NoThrow:
    return {0, 0, 0};

  case EST_Dynamic:
    return {NumExceptions, 0, 0};

  case EST_DependentNoexcept:
  case EST_NoexceptFalse:
  case EST_NoexceptTrue:
    return {0, 1, 0};

  case EST_Uninstantiated:
    return {0, 0, 2};

  case EST_Unevaluated:
    return {0, 0, 1};
  }
  llvm_unreachable("bad exception specification kind")__builtin_unreachable();
}

/// Return the number and kind of trailing objects
/// related to the exception specification.
ExceptionSpecSizeHolder getExceptionSpecSize() const {
  return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
static bool hasExtraBitfields(ExceptionSpecificationType EST) {
  // If the exception spec type is EST_Dynamic then we have > 0 exception
  // types and the exact number is stored in FunctionTypeExtraBitfields.
  return EST == EST_Dynamic;
}

/// Whether the trailing FunctionTypeExtraBitfields is present.
bool hasExtraBitfields() const {
  return hasExtraBitfields(getExceptionSpecType());
}

bool hasExtQualifiers() const {
  return FunctionTypeBits.HasExtQuals;
}

4093public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")(static_cast<void> (0));
  return param_type_begin()[i];
}

ArrayRef<QualType> getParamTypes() const {
  return llvm::makeArrayRef(param_type_begin(), param_type_end());
}

ExtProtoInfo getExtProtoInfo() const {
  ExtProtoInfo EPI;
  EPI.ExtInfo = getExtInfo();
  EPI.Variadic = isVariadic();
  EPI.EllipsisLoc = getEllipsisLoc();
  EPI.HasTrailingReturn = hasTrailingReturn();
  EPI.ExceptionSpec = getExceptionSpecInfo();
  EPI.TypeQuals = getMethodQuals();
  EPI.RefQualifier = getRefQualifier();
  EPI.ExtParameterInfos = getExtParameterInfosOrNull();
  return EPI;
}

/// Get the kind of exception specification on this function.
ExceptionSpecificationType getExceptionSpecType() const {
  return static_cast<ExceptionSpecificationType>(
      FunctionTypeBits.ExceptionSpecType);
}

/// Return whether this function has any kind of exception spec.
bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }

/// Return whether this function has a dynamic (throw) exception spec.
bool hasDynamicExceptionSpec() const {
  return isDynamicExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a noexcept exception spec.
bool hasNoexceptExceptionSpec() const {
  return isNoexceptExceptionSpec(getExceptionSpecType());
}

/// Return whether this function has a dependent exception spec.
bool hasDependentExceptionSpec() const;

/// Return whether this function has an instantiation-dependent exception
/// spec.
bool hasInstantiationDependentExceptionSpec() const;

/// Return all the available information about this type's exception spec.
ExceptionSpecInfo getExceptionSpecInfo() const {
  ExceptionSpecInfo Result;
  Result.Type = getExceptionSpecType();
  if (Result.Type == EST_Dynamic) {
    Result.Exceptions = exceptions();
  } else if (isComputedNoexcept(Result.Type)) {
    Result.NoexceptExpr = getNoexceptExpr();
  } else if (Result.Type == EST_Uninstantiated) {
    Result.SourceDecl = getExceptionSpecDecl();
    Result.SourceTemplate = getExceptionSpecTemplate();
  } else if (Result.Type == EST_Unevaluated) {
    Result.SourceDecl = getExceptionSpecDecl();
  }
  return Result;
}

/// Return the number of types in the exception specification.
unsigned getNumExceptions() const {
  return getExceptionSpecType() == EST_Dynamic
             ? getTrailingObjects<FunctionTypeExtraBitfields>()
                   ->NumExceptionType
             : 0;
}

/// Return the ith exception type, where 0 <= i < getNumExceptions().
QualType getExceptionType(unsigned i) const {
  assert(i < getNumExceptions() && "Invalid exception number!")(static_cast<void> (0));
  return exception_begin()[i];
}

/// Return the expression inside noexcept(expression), or a null pointer
/// if there is none (because the exception spec is not of this form).
Expr *getNoexceptExpr() const {
  if (!isComputedNoexcept(getExceptionSpecType()))
    return nullptr;
  return *getTrailingObjects<Expr *>();
}

/// If this function type has an exception specification which hasn't
/// been determined yet (either because it has not been evaluated or because
/// it has not been instantiated), this is the function whose exception
/// specification is represented by this type.
FunctionDecl *getExceptionSpecDecl() const {
  if (getExceptionSpecType() != EST_Uninstantiated &&
      getExceptionSpecType() != EST_Unevaluated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[0];
}

/// If this function type has an uninstantiated exception
/// specification, this is the function whose exception specification
/// should be instantiated to find the exception specification for
/// this type.
FunctionDecl *getExceptionSpecTemplate() const {
  if (getExceptionSpecType() != EST_Uninstantiated)
    return nullptr;
  return getTrailingObjects<FunctionDecl *>()[1];
}

/// Determine whether this function type has a non-throwing exception
/// specification.
CanThrowResult canThrow() const;

/// Determine whether this function type has a non-throwing exception
/// specification. If this depends on template arguments, returns
/// \c ResultIfDependent.
bool isNothrow(bool ResultIfDependent = false) const {
  return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
}

/// Whether this function prototype is variadic.
bool isVariadic() const { return FunctionTypeBits.Variadic; }

SourceLocation getEllipsisLoc() const {
  return isVariadic() ? *getTrailingObjects<SourceLocation>()
                      : SourceLocation();
}

/// Determines whether this function prototype contains a
/// parameter pack at the end.
///
/// A function template whose last parameter is a parameter pack can be
/// called with an arbitrary number of arguments, much like a variadic
/// function.
bool isTemplateVariadic() const;

/// Whether this function prototype has a trailing return type.
bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }

Qualifiers getMethodQuals() const {
  if (hasExtQualifiers())
    return *getTrailingObjects<Qualifiers>();
  else
    return getFastTypeQuals();
}

/// Retrieve the ref-qualifier associated with this function type.
RefQualifierKind getRefQualifier() const {
  return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
}

using param_type_iterator = const QualType *;
using param_type_range = llvm::iterator_range<param_type_iterator>;

param_type_range param_types() const {
  return param_type_range(param_type_begin(), param_type_end());
}

param_type_iterator param_type_begin() const {
  return getTrailingObjects<QualType>();
}

param_type_iterator param_type_end() const {
  return param_type_begin() + getNumParams();
}

using exception_iterator = const QualType *;

ArrayRef<QualType> exceptions() const {
  return llvm::makeArrayRef(exception_begin(), exception_end());
}

exception_iterator exception_begin() const {
  return reinterpret_cast<exception_iterator>(
      getTrailingObjects<ExceptionType>());
}

exception_iterator exception_end() const {
  return exception_begin() + getNumExceptions();
}

/// Is there any interesting extra information for any of the parameters
/// of this function type?
bool hasExtParameterInfos() const {
  return FunctionTypeBits.HasExtParameterInfos;
}

ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
  assert(hasExtParameterInfos())(static_cast<void> (0));
  return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
                                    getNumParams());
}

/// Return a pointer to the beginning of the array of extra parameter
/// information, if present, or else null if none of the parameters
/// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
const ExtParameterInfo *getExtParameterInfosOrNull() const {
  if (!hasExtParameterInfos())
    return nullptr;
  return getTrailingObjects<ExtParameterInfo>();
}

ExtParameterInfo getExtParameterInfo(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].getABI();
  return ParameterABI::Ordinary;
}

bool isParamConsumed(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")(static_cast<void> (0));
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
  return false;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void printExceptionSpecification(raw_ostream &OS,
                                 const PrintingPolicy &Policy) const;

static bool classof(const Type *T) {
  return T->getTypeClass() == FunctionProto;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                    param_type_iterator ArgTys, unsigned NumArgs,
                    const ExtProtoInfo &EPI, const ASTContext &Context,
                    bool Canonical);
4333};

4335/// Represents the dependent type named by a dependently-scoped
4336/// typename using declaration, e.g.
4337///   using typename Base<T>::foo;
4338///
4339/// Template instantiation turns these into the underlying type.
4340class UnresolvedUsingType : public Type {
friend class ASTContext; // ASTContext creates these.

UnresolvedUsingTypenameDecl *Decl;

UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
    : Type(UnresolvedUsing, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}

4350public:
UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnresolvedUsing;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  return Profile(ID, Decl);
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    UnresolvedUsingTypenameDecl *D) {
  ID.AddPointer(D);
}
4368};

4370class TypedefType : public Type {
TypedefNameDecl *Decl;

4373private:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
            QualType can);

4379public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4386};

4388/// Sugar type that represents a type that was qualified by a qualifier written
4389/// as a macro invocation.
4390class MacroQualifiedType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType UnderlyingTy;
const IdentifierInfo *MacroII;

MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
                   const IdentifierInfo *MacroII)
    : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
      UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
  assert(isa<AttributedType>(UnderlyingTy) &&(static_cast<void> (0))
         "Expected a macro qualified type to only wrap attributed types.")(static_cast<void> (0));
}

4404public:
const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
QualType getUnderlyingType() const { return UnderlyingTy; }

/// Return this attributed type's modified type with no qualifiers attached to
/// it.
QualType getModifiedType() const;

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == MacroQualified;
}
4418};

4420/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4421class TypeOfExprType : public Type {
Expr *TOExpr;

4424protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4429public:
Expr *getUnderlyingExpr() const { return TOExpr; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4439};

4441/// Internal representation of canonical, dependent
4442/// `typeof(expr)` types.
4443///
4444/// This class is used internally by the ASTContext to manage
4445/// canonical, dependent types, only. Clients will only see instances
4446/// of this class via TypeOfExprType nodes.
4447class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4451public:
DependentTypeOfExprType(const ASTContext &Context, Expr *E)
    : TypeOfExprType(E), Context(Context) {}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4461};

4463/// Represents `typeof(type)`, a GCC extension.
4464class TypeOfType : public Type {
friend class ASTContext; // ASTContext creates these.

QualType TOType;

TypeOfType(QualType T, QualType can)
    : Type(TypeOf, can, T->getDependence()), TOType(T) {
  assert(!isa<TypedefType>(can) && "Invalid canonical type")(static_cast<void> (0));
}

4474public:
QualType getUnderlyingType() const { return TOType; }

/// Remove a single level of sugar.
QualType desugar() const { return getUnderlyingType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4484};

4486/// Represents the type `decltype(expr)` (C++11).
4487class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4491protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4496public:
Expr *getUnderlyingExpr() const { return E; }
QualType getUnderlyingType() const { return UnderlyingType; }

/// Remove a single level of sugar.
QualType desugar() const;

/// Returns whether this type directly provides sugar.
bool isSugared() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4507};

4509/// Internal representation of canonical, dependent
4510/// decltype(expr) types.
4511///
4512/// This class is used internally by the ASTContext to manage
4513/// canonical, dependent types, only. Clients will only see instances
4514/// of this class via DecltypeType nodes.
4515class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4518public:
DependentDecltypeType(const ASTContext &Context, Expr *E);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, getUnderlyingExpr());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    Expr *E);
4527};

4529/// A unary type transform, which is a type constructed from another.
4530class UnaryTransformType : public Type {
4531public:
enum UTTKind {
  EnumUnderlyingType
};

4536private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4545protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4551public:
bool isSugared() const { return !isDependentType(); }
QualType desugar() const { return UnderlyingType; }

QualType getUnderlyingType() const { return UnderlyingType; }
QualType getBaseType() const { return BaseType; }

UTTKind getUTTKind() const { return UKind; }

static bool classof(const Type *T) {
  return T->getTypeClass() == UnaryTransform;
}
4563};

4565/// Internal representation of canonical, dependent
4566/// __underlying_type(type) types.
4567///
4568/// This class is used internally by the ASTContext to manage
4569/// canonical, dependent types, only. Clients will only see instances
4570/// of this class via UnaryTransformType nodes.
4571class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4573public:
DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
                            UTTKind UKind);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getBaseType(), getUTTKind());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                    UTTKind UKind) {
  ID.AddPointer(BaseType.getAsOpaquePtr());
  ID.AddInteger((unsigned)UKind);
}
4586};

4588class TagType : public Type {
friend class ASTReader;
template <class T> friend class serialization::AbstractTypeReader;

/// Stores the TagDecl associated with this type. The decl may point to any
/// TagDecl that declares the entity.
TagDecl *decl;

4596protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4599public:
TagDecl *getDecl() const;

/// Determines whether this type is in the process of being defined.
bool isBeingDefined() const;

static bool classof(const Type *T) {
  return T->getTypeClass() == Enum || T->getTypeClass() == Record;
}
4608};

4610/// A helper class that allows the use of isa/cast/dyncast
4611/// to detect TagType objects of structs/unions/classes.
4612class RecordType : public TagType {
4613protected:
friend class ASTContext; // ASTContext creates these.

explicit RecordType(const RecordDecl *D)
    : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
explicit RecordType(TypeClass TC, RecordDecl *D)
    : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4621public:
RecordDecl *getDecl() const {
  return reinterpret_cast<RecordDecl*>(TagType::getDecl());
}

/// Recursively check all fields in the record for const-ness. If any field
/// is declared const, return true. Otherwise, return false.
bool hasConstFields() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4634};

4636/// A helper class that allows the use of isa/cast/dyncast
4637/// to detect TagType objects of enums.
4638class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4644public:
EnumDecl *getDecl() const {
  return reinterpret_cast<EnumDecl*>(TagType::getDecl());
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4653};

4655/// An attributed type is a type to which a type attribute has been applied.
4656///
4657/// The "modified type" is the fully-sugared type to which the attributed
4658/// type was applied; generally it is not canonically equivalent to the
4659/// attributed type. The "equivalent type" is the minimally-desugared type
4660/// which the type is canonically equivalent to.
4661///
4662/// For example, in the following attributed type:
4663///     int32_t __attribute__((vector_size(16)))
4664///   - the modified type is the TypedefType for int32_t
4665///   - the equivalent type is VectorType(16, int32_t)
4666///   - the canonical type is VectorType(16, int)
4667class AttributedType : public Type, public llvm::FoldingSetNode {
4668public:
using Kind = attr::Kind;

4671private:
friend class ASTContext; // ASTContext creates these

QualType ModifiedType;
QualType EquivalentType;

AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
               QualType equivalent)
    : Type(Attributed, canon, equivalent->getDependence()),
      ModifiedType(modified), EquivalentType(equivalent) {
  AttributedTypeBits.AttrKind = attrKind;
}

4684public:
Kind getAttrKind() const {
  return static_cast<Kind>(AttributedTypeBits.AttrKind);
}

QualType getModifiedType() const { return ModifiedType; }
QualType getEquivalentType() const { return EquivalentType; }

bool isSugared() const { return true; }
QualType desugar() const { return getEquivalentType(); }

/// Does this attribute behave like a type qualifier?
///
/// A type qualifier adjusts a type to provide specialized rules for
/// a specific object, like the standard const and volatile qualifiers.
/// This includes attributes controlling things like nullability,
/// address spaces, and ARC ownership.  The value of the object is still
/// largely described by the modified type.
///
/// In contrast, many type attributes "rewrite" their modified type to
/// produce a fundamentally different type, not necessarily related in any
/// formalizable way to the original type.  For example, calling convention
/// and vector attributes are not simple type qualifiers.
///
/// Type qualifiers are often, but not always, reflected in the canonical
/// type.
bool isQualifier() const;

bool isMSTypeSpec() const;

bool isCallingConv() const;

llvm::Optional<NullabilityKind> getImmediateNullability() const;

/// Retrieve the attribute kind corresponding to the given
/// nullability kind.
static Kind getNullabilityAttrKind(NullabilityKind kind) {
  switch (kind) {
  case NullabilityKind::NonNull:
    return attr::TypeNonNull;

  case NullabilityKind::Nullable:
    return attr::TypeNullable;

  case NullabilityKind::NullableResult:
    return attr::TypeNullableResult;

  case NullabilityKind::Unspecified:
    return attr::TypeNullUnspecified;
  }
  llvm_unreachable("Unknown nullability kind.")__builtin_unreachable();
}

/// Strip off the top-level nullability annotation on the given
/// type, if it's there.
///
/// \param T The type to strip. If the type is exactly an
/// AttributedType specifying nullability (without looking through
/// type sugar), the nullability is returned and this type changed
/// to the underlying modified type.
///
/// \returns the top-level nullability, if present.
static Optional<NullabilityKind> stripOuterNullability(QualType &T);

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
}

static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
                    QualType modified, QualType equivalent) {
  ID.AddInteger(attrKind);
  ID.AddPointer(modified.getAsOpaquePtr());
  ID.AddPointer(equivalent.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Attributed;
}
4762};

4764class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

// Helper data collector for canonical types.
struct CanonicalTTPTInfo {
  unsigned Depth : 15;
  unsigned ParameterPack : 1;
  unsigned Index : 16;
};

union {
  // Info for the canonical type.
  CanonicalTTPTInfo CanTTPTInfo;

  // Info for the non-canonical type.
  TemplateTypeParmDecl *TTPDecl;
};

/// Build a non-canonical type.
TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
    : Type(TemplateTypeParm, Canon,
           TypeDependence::DependentInstantiation |
               (Canon->getDependence() & TypeDependence::UnexpandedPack)),
      TTPDecl(TTPDecl) {}

/// Build the canonical type.
TemplateTypeParmType(unsigned D, unsigned I, bool PP)
    : Type(TemplateTypeParm, QualType(this, 0),
           TypeDependence::DependentInstantiation |
               (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
  CanTTPTInfo.Depth = D;
  CanTTPTInfo.Index = I;
  CanTTPTInfo.ParameterPack = PP;
}

const CanonicalTTPTInfo& getCanTTPTInfo() const {
  QualType Can = getCanonicalTypeInternal();
  return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
}

4804public:
unsigned getDepth() const { return getCanTTPTInfo().Depth; }
unsigned getIndex() const { return getCanTTPTInfo().Index; }
bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }

TemplateTypeParmDecl *getDecl() const {
  return isCanonicalUnqualified() ? nullptr : TTPDecl;
}

IdentifierInfo *getIdentifier() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
                    unsigned Index, bool ParameterPack,
                    TemplateTypeParmDecl *TTPDecl) {
  ID.AddInteger(Depth);
  ID.AddInteger(Index);
  ID.AddBoolean(ParameterPack);
  ID.AddPointer(TTPDecl);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateTypeParm;
}
4834};

4836/// Represents the result of substituting a type for a template
4837/// type parameter.
4838///
4839/// Within an instantiated template, all template type parameters have
4840/// been replaced with these.  They are used solely to record that a
4841/// type was originally written as a template type parameter;
4842/// therefore they are never canonical.
4843class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

// The original type parameter.
const TemplateTypeParmType *Replaced;

SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
    : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
      Replaced(Param) {}

4853public:
/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

/// Gets the type that was substituted for the template
/// parameter.
QualType getReplacementType() const {
  return getCanonicalTypeInternal();
}

bool isSugared() const { return true; }
QualType desugar() const { return getReplacementType(); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getReplacedParameter(), getReplacementType());
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    QualType Replacement) {
  ID.AddPointer(Replaced);
  ID.AddPointer(Replacement.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParm;
}
4882};

4884/// Represents the result of substituting a set of types for a template
4885/// type parameter pack.
4886///
4887/// When a pack expansion in the source code contains multiple parameter packs
4888/// and those parameter packs correspond to different levels of template
4889/// parameter lists, this type node is used to represent a template type
4890/// parameter pack from an outer level, which has already had its argument pack
4891/// substituted but that still lives within a pack expansion that itself
4892/// could not be instantiated. When actually performing a substitution into
4893/// that pack expansion (e.g., when all template parameters have corresponding
4894/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4895/// at the current pack substitution index.
4896class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
friend class ASTContext;

/// The original type parameter.
const TemplateTypeParmType *Replaced;

/// A pointer to the set of template arguments that this
/// parameter pack is instantiated with.
const TemplateArgument *Arguments;

SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
                              QualType Canon,
                              const TemplateArgument &ArgPack);

4910public:
IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }

/// Gets the template parameter that was substituted for.
const TemplateTypeParmType *getReplacedParameter() const {
  return Replaced;
}

unsigned getNumArgs() const {
  return SubstTemplateTypeParmPackTypeBits.NumArgs;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

TemplateArgument getArgumentPack() const;

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const TemplateTypeParmType *Replaced,
                    const TemplateArgument &ArgPack);

static bool classof(const Type *T) {
  return T->getTypeClass() == SubstTemplateTypeParmPack;
}
4935};

4937/// Common base class for placeholders for types that get replaced by
4938/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4939/// class template types, and constrained type names.
4940///
4941/// These types are usually a placeholder for a deduced type. However, before
4942/// the initializer is attached, or (usually) if the initializer is
4943/// type-dependent, there is no deduced type and the type is canonical. In
4944/// the latter case, it is also a dependent type.
4945class DeducedType : public Type {
4946protected:
DeducedType(TypeClass TC, QualType DeducedAsType,
            TypeDependence ExtraDependence)
    : Type(TC,
           // FIXME: Retain the sugared deduced type?
           DeducedAsType.isNull() ? QualType(this, 0)
                                  : DeducedAsType.getCanonicalType(),
           ExtraDependence | (DeducedAsType.isNull()
                                  ? TypeDependence::None
                                  : DeducedAsType->getDependence() &
                                        ~TypeDependence::VariablyModified)) {}

4958public:
bool isSugared() const { return !isCanonicalUnqualified(); }
QualType desugar() const { return getCanonicalTypeInternal(); }

/// Get the type deduced for this placeholder type, or null if it's
/// either not been deduced or was deduced to a dependent type.
QualType getDeducedType() const {
  return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
}
bool isDeduced() const {
  return !isCanonicalUnqualified() || isDependentType();
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto ||
         T->getTypeClass() == DeducedTemplateSpecialization;
}
4975};

4977/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4978/// by a type-constraint.
4979class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

ConceptDecl *TypeConstraintConcept;

AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
         TypeDependence ExtraDependence, ConceptDecl *CD,
         ArrayRef<TemplateArgument> TypeConstraintArgs);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

4996public:
/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return AutoTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
  return {getArgs(), getNumArgs()};
}

ConceptDecl *getTypeConstraintConcept() const {
  return TypeConstraintConcept;
}

bool isConstrained() const {
  return TypeConstraintConcept != nullptr;
}

bool isDecltypeAuto() const {
  return getKeyword() == AutoTypeKeyword::DecltypeAuto;
}

AutoTypeKeyword getKeyword() const {
  return (AutoTypeKeyword)AutoTypeBits.Keyword;
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
          getTypeConstraintConcept(), getTypeConstraintArguments());
}

static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    QualType Deduced, AutoTypeKeyword Keyword,
                    bool IsDependent, ConceptDecl *CD,
                    ArrayRef<TemplateArgument> Arguments);

static bool classof(const Type *T) {
  return T->getTypeClass() == Auto;
}
5042};

5044/// Represents a C++17 deduced template specialization type.
5045class DeducedTemplateSpecializationType : public DeducedType,
                                        public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template whose arguments will be deduced.
TemplateName Template;

DeducedTemplateSpecializationType(TemplateName Template,
                                  QualType DeducedAsType,
                                  bool IsDeducedAsDependent)
    : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                  toTypeDependence(Template.getDependence()) |
                      (IsDeducedAsDependent
                           ? TypeDependence::DependentInstantiation
                           : TypeDependence::None)),
      Template(Template) {}

5062public:
/// Retrieve the name of the template that we are deducing.
TemplateName getTemplateName() const { return Template;}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
                    QualType Deduced, bool IsDependent) {
  Template.Profile(ID);
  ID.AddPointer(Deduced.getAsOpaquePtr());
  ID.AddBoolean(IsDependent);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DeducedTemplateSpecialization;
}
5080};

5082/// Represents a type template specialization; the template
5083/// must be a class template, a type alias template, or a template
5084/// template parameter.  A template which cannot be resolved to one of
5085/// these, e.g. because it is written with a dependent scope
5086/// specifier, is instead represented as a
5087/// @c DependentTemplateSpecializationType.
5088///
5089/// A non-dependent template specialization type is always "sugar",
5090/// typically for a \c RecordType.  For example, a class template
5091/// specialization type of \c vector<int> will refer to a tag type for
5092/// the instantiation \c std::vector<int, std::allocator<int>>
5093///
5094/// Template specializations are dependent if either the template or
5095/// any of the template arguments are dependent, in which case the
5096/// type may also be canonical.
5097///
5098/// Instances of this type are allocated with a trailing array of
5099/// TemplateArguments, followed by a QualType representing the
5100/// non-canonical aliased type when the template is a type alias
5101/// template.
5102class alignas(8) TemplateSpecializationType
  : public Type,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The name of the template being specialized.  This is
/// either a TemplateName::Template (in which case it is a
/// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
/// TypeAliasTemplateDecl*), a
/// TemplateName::SubstTemplateTemplateParmPack, or a
/// TemplateName::SubstTemplateTemplateParm (in which case the
/// replacement must, recursively, be one of these).
TemplateName Template;

TemplateSpecializationType(TemplateName T,
                           ArrayRef<TemplateArgument> Args,
                           QualType Canon,
                           QualType Aliased);

5121public:
/// Determine whether any of the given template arguments are dependent.
///
/// The converted arguments should be supplied when known; whether an
/// argument is dependent can depend on the conversions performed on it
/// (for example, a 'const int' passed as a template argument might be
/// dependent if the parameter is a reference but non-dependent if the
/// parameter is an int).
///
/// Note that the \p Args parameter is unused: this is intentional, to remind
/// the caller that they need to pass in the converted arguments, not the
/// specified arguments.
static bool
anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                              ArrayRef<TemplateArgument> Converted);
static bool
anyDependentTemplateArguments(const TemplateArgumentListInfo &,
                              ArrayRef<TemplateArgument> Converted);
static bool anyInstantiationDependentTemplateArguments(
    ArrayRef<TemplateArgumentLoc> Args);

/// True if this template specialization type matches a current
/// instantiation in the context in which it is found.
bool isCurrentInstantiation() const {
  return isa<InjectedClassNameType>(getCanonicalTypeInternal());
}

/// Determine if this template specialization type is for a type alias
/// template that has been substituted.
///
/// Nearly every template specialization type whose template is an alias
/// template will be substituted. However, this is not the case when
/// the specialization contains a pack expansion but the template alias
/// does not have a corresponding parameter pack, e.g.,
///
/// \code
/// template<typename T, typename U, typename V> struct S;
/// template<typename T, typename U> using A = S<T, int, U>;
/// template<typename... Ts> struct X {
///   typedef A<Ts...> type; // not a type alias
/// };
/// \endcode
bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }

/// Get the aliased type, if this is a specialization of a type alias
/// template.
QualType getAliasedType() const {
  assert(isTypeAlias() && "not a type alias template specialization")(static_cast<void> (0));
  return *reinterpret_cast<const QualType*>(end());
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // defined inline in TemplateBase.h

/// Retrieve the name of the template that we are specializing.
TemplateName getTemplateName() const { return Template; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return reinterpret_cast<const TemplateArgument *>(this + 1);
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return TemplateSpecializationTypeBits.NumArgs;
}

/// Retrieve a specific template argument as a type.
/// \pre \c isArgType(Arg)
const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

bool isSugared() const {
  return !isDependentType() || isCurrentInstantiation() || isTypeAlias();
}

QualType desugar() const {
  return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
}

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
  Profile(ID, Template, template_arguments(), Ctx);
  if (isTypeAlias())
    getAliasedType().Profile(ID);
}

static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                    ArrayRef<TemplateArgument> Args,
                    const ASTContext &Context);

static bool classof(const Type *T) {
  return T->getTypeClass() == TemplateSpecialization;
}
5219};

5221/// Print a template argument list, including the '<' and '>'
5222/// enclosing the template arguments.
5223void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5228void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5233void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5238/// The injected class name of a C++ class template or class
5239/// template partial specialization.  Used to record that a type was
5240/// spelled with a bare identifier rather than as a template-id; the
5241/// equivalent for non-templated classes is just RecordType.
5242///
5243/// Injected class name types are always dependent.  Template
5244/// instantiation turns these into RecordTypes.
5245///
5246/// Injected class name types are always canonical.  This works
5247/// because it is impossible to compare an injected class name type
5248/// with the corresponding non-injected template type, for the same
5249/// reason that it is impossible to directly compare template
5250/// parameters from different dependent contexts: injected class name
5251/// types can only occur within the scope of a particular templated
5252/// declaration, and within that scope every template specialization
5253/// will canonicalize to the injected class name (when appropriate
5254/// according to the rules of the language).
5255class InjectedClassNameType : public Type {
friend class ASTContext; // ASTContext creates these.
friend class ASTNodeImporter;
friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
                        // currently suitable for AST reading, too much
                        // interdependencies.
template <class T> friend class serialization::AbstractTypeReader;

CXXRecordDecl *Decl;

/// The template specialization which this type represents.
/// For example, in
///   template <class T> class A { ... };
/// this is A<T>, whereas in
///   template <class X, class Y> class A<B<X,Y> > { ... };
/// this is A<B<X,Y> >.
///
/// It is always unqualified, always a template specialization type,
/// and always dependent.
QualType InjectedType;

InjectedClassNameType(CXXRecordDecl *D, QualType TST)
    : Type(InjectedClassName, QualType(),
           TypeDependence::DependentInstantiation),
      Decl(D), InjectedType(TST) {
  assert(isa<TemplateSpecializationType>(TST))(static_cast<void> (0));
  assert(!TST.hasQualifiers())(static_cast<void> (0));
  assert(TST->isDependentType())(static_cast<void> (0));
}

5285public:
QualType getInjectedSpecializationType() const { return InjectedType; }

const TemplateSpecializationType *getInjectedTST() const {
  return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
}

TemplateName getTemplateName() const {
  return getInjectedTST()->getTemplateName();
}

CXXRecordDecl *getDecl() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == InjectedClassName;
}
5304};

5306/// The kind of a tag type.
5307enum TagTypeKind {
/// The "struct" keyword.
TTK_Struct,

/// The "__interface" keyword.
TTK_Interface,

/// The "union" keyword.
TTK_Union,

/// The "class" keyword.
TTK_Class,

/// The "enum" keyword.
TTK_Enum
5322};

5324/// The elaboration keyword that precedes a qualified type name or
5325/// introduces an elaborated-type-specifier.
5326enum ElaboratedTypeKeyword {
/// The "struct" keyword introduces the elaborated-type-specifier.
ETK_Struct,

/// The "__interface" keyword introduces the elaborated-type-specifier.
ETK_Interface,

/// The "union" keyword introduces the elaborated-type-specifier.
ETK_Union,

/// The "class" keyword introduces the elaborated-type-specifier.
ETK_Class,

/// The "enum" keyword introduces the elaborated-type-specifier.
ETK_Enum,

/// The "typename" keyword precedes the qualified type name, e.g.,
/// \c typename T::type.
ETK_Typename,

/// No keyword precedes the qualified type name.
ETK_None
5348};

5350/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5351/// The keyword in stored in the free bits of the base class.
5352/// Also provides a few static helpers for converting and printing
5353/// elaborated type keyword and tag type kind enumerations.
5354class TypeWithKeyword : public Type {
5355protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, TypeDependence Dependence)
    : Type(tc, Canonical, Dependence) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5362public:
ElaboratedTypeKeyword getKeyword() const {
  return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
}

/// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);

/// Converts a type specifier (DeclSpec::TST) into a tag type kind.
/// It is an error to provide a type specifier which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);

/// Converts a TagTypeKind into an elaborated type keyword.
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);

/// Converts an elaborated type keyword into a TagTypeKind.
/// It is an error to provide an elaborated type keyword
/// which *isn't* a tag kind here.
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword);

static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword);

static StringRef getKeywordName(ElaboratedTypeKeyword Keyword);

static StringRef getTagTypeKindName(TagTypeKind Kind) {
  return getKeywordName(getKeywordForTagTypeKind(Kind));
}

class CannotCastToThisType {};
static CannotCastToThisType classof(const Type *);
5392};

5394/// Represents a type that was referred to using an elaborated type
5395/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5396/// or both.
5397///
5398/// This type is used to keep track of a type name as written in the
5399/// source code, including tag keywords and any nested-name-specifiers.
5400/// The type itself is always "sugar", used to express what was written
5401/// in the source code but containing no additional semantic information.
5402class ElaboratedType final
  : public TypeWithKeyword,
    public llvm::FoldingSetNode,
    private llvm::TrailingObjects<ElaboratedType, TagDecl *> {
friend class ASTContext; // ASTContext creates these
friend TrailingObjects;

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this qualified name refers to.
QualType NamedType;

/// The (re)declaration of this tag type owned by this occurrence is stored
/// as a trailing object if there is one. Use getOwnedTagDecl to obtain
/// it, or obtain a null pointer if there is none.

ElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
               QualType NamedType, QualType CanonType, TagDecl *OwnedTagDecl)
    : TypeWithKeyword(Keyword, Elaborated, CanonType,
                      // Any semantic dependence on the qualifier will have
                      // been incorporated into NamedType. We still need to
                      // track syntactic (instantiation / error / pack)
                      // dependence on the qualifier.
                      NamedType->getDependence() |
                          (NNS ? toSyntacticDependence(
                                     toTypeDependence(NNS->getDependence()))
                               : TypeDependence::None)),
      NNS(NNS), NamedType(NamedType) {
  ElaboratedTypeBits.HasOwnedTagDecl = false;
  if (OwnedTagDecl) {
    ElaboratedTypeBits.HasOwnedTagDecl = true;
    *getTrailingObjects<TagDecl *>() = OwnedTagDecl;
  }
  assert(!(Keyword == ETK_None && NNS == nullptr) &&(static_cast<void> (0))
         "ElaboratedType cannot have elaborated type keyword "(static_cast<void> (0))
         "and name qualifier both null.")(static_cast<void> (0));
}

5441public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the qualified-id.
QualType getNamedType() const { return NamedType; }

/// Remove a single level of sugar.
QualType desugar() const { return getNamedType(); }

/// Returns whether this type directly provides sugar.
bool isSugared() const { return true; }

/// Return the (re)declaration of this type owned by this occurrence of this
/// type, or nullptr if there is none.
TagDecl *getOwnedTagDecl() const {
  return ElaboratedTypeBits.HasOwnedTagDecl ? *getTrailingObjects<TagDecl *>()
                                            : nullptr;
}

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, NamedType, getOwnedTagDecl());
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, QualType NamedType,
                    TagDecl *OwnedTagDecl) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  NamedType.Profile(ID);
  ID.AddPointer(OwnedTagDecl);
}

static bool classof(const Type *T) { return T->getTypeClass() == Elaborated; }
5475};

5477/// Represents a qualified type name for which the type name is
5478/// dependent.
5479///
5480/// DependentNameType represents a class of dependent types that involve a
5481/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5482/// name of a type. The DependentNameType may start with a "typename" (for a
5483/// typename-specifier), "class", "struct", "union", or "enum" (for a
5484/// dependent elaborated-type-specifier), or nothing (in contexts where we
5485/// know that we must be referring to a type, e.g., in a base class specifier).
5486/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5487/// mode, this type is used with non-dependent names to delay name lookup until
5488/// instantiation.
5489class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The type that this typename specifier refers to.
const IdentifierInfo *Name;

DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
                  const IdentifierInfo *Name, QualType CanonType)
    : TypeWithKeyword(Keyword, DependentName, CanonType,
                      TypeDependence::DependentInstantiation |
                          toTypeDependence(NNS->getDependence())),
      NNS(NNS), Name(Name) {}

5505public:
/// Retrieve the qualification on this type.
NestedNameSpecifier *getQualifier() const { return NNS; }

/// Retrieve the type named by the typename specifier as an identifier.
///
/// This routine will return a non-NULL identifier pointer when the
/// form of the original typename was terminated by an identifier,
/// e.g., "typename T::type".
const IdentifierInfo *getIdentifier() const {
  return Name;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getKeyword(), NNS, Name);
}

static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *NNS, const IdentifierInfo *Name) {
  ID.AddInteger(Keyword);
  ID.AddPointer(NNS);
  ID.AddPointer(Name);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentName;
}
5535};

5537/// Represents a template specialization type whose template cannot be
5538/// resolved, e.g.
5539///   A<T>::template B<T>
5540class alignas(8) DependentTemplateSpecializationType
  : public TypeWithKeyword,
    public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The nested name specifier containing the qualifier.
NestedNameSpecifier *NNS;

/// The identifier of the template.
const IdentifierInfo *Name;

DependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
                                    NestedNameSpecifier *NNS,
                                    const IdentifierInfo *Name,
                                    ArrayRef<TemplateArgument> Args,
                                    QualType Canon);

const TemplateArgument *getArgBuffer() const {
  return reinterpret_cast<const TemplateArgument*>(this+1);
}

TemplateArgument *getArgBuffer() {
  return reinterpret_cast<TemplateArgument*>(this+1);
}

5565public:
NestedNameSpecifier *getQualifier() const { return NNS; }
const IdentifierInfo *getIdentifier() const { return Name; }

/// Retrieve the template arguments.
const TemplateArgument *getArgs() const {
  return getArgBuffer();
}

/// Retrieve the number of template arguments.
unsigned getNumArgs() const {
  return DependentTemplateSpecializationTypeBits.NumArgs;
}

const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h

ArrayRef<TemplateArgument> template_arguments() const {
  return {getArgs(), getNumArgs()};
}

using iterator = const TemplateArgument *;

iterator begin() const { return getArgs(); }
iterator end() const; // inline in TemplateBase.h

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
  Profile(ID, Context, getKeyword(), NNS, Name, {getArgs(), getNumArgs()});
}

static void Profile(llvm::FoldingSetNodeID &ID,
                    const ASTContext &Context,
                    ElaboratedTypeKeyword Keyword,
                    NestedNameSpecifier *Qualifier,
                    const IdentifierInfo *Name,
                    ArrayRef<TemplateArgument> Args);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentTemplateSpecialization;
}
5607};

5609/// Represents a pack expansion of types.
5610///
5611/// Pack expansions are part of C++11 variadic templates. A pack
5612/// expansion contains a pattern, which itself contains one or more
5613/// "unexpanded" parameter packs. When instantiated, a pack expansion
5614/// produces a series of types, each instantiated from the pattern of
5615/// the expansion, where the Ith instantiation of the pattern uses the
5616/// Ith arguments bound to each of the unexpanded parameter packs. The
5617/// pack expansion is considered to "expand" these unexpanded
5618/// parameter packs.
5619///
5620/// \code
5621/// template<typename ...Types> struct tuple;
5622///
5623/// template<typename ...Types>
5624/// struct tuple_of_references {
5625///   typedef tuple<Types&...> type;
5626/// };
5627/// \endcode
5628///
5629/// Here, the pack expansion \c Types&... is represented via a
5630/// PackExpansionType whose pattern is Types&.
5631class PackExpansionType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these

/// The pattern of the pack expansion.
QualType Pattern;

PackExpansionType(QualType Pattern, QualType Canon,
                  Optional<unsigned> NumExpansions)
    : Type(PackExpansion, Canon,
           (Pattern->getDependence() | TypeDependence::Dependent |
            TypeDependence::Instantiation) &
               ~TypeDependence::UnexpandedPack),
      Pattern(Pattern) {
  PackExpansionTypeBits.NumExpansions =
      NumExpansions ? *NumExpansions + 1 : 0;
}

5648public:
/// Retrieve the pattern of this pack expansion, which is the
/// type that will be repeatedly instantiated when instantiating the
/// pack expansion itself.
QualType getPattern() const { return Pattern; }

/// Retrieve the number of expansions that this pack expansion will
/// generate, if known.
Optional<unsigned> getNumExpansions() const {
  if (PackExpansionTypeBits.NumExpansions)
    return PackExpansionTypeBits.NumExpansions - 1;
  return None;
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPattern(), getNumExpansions());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
                    Optional<unsigned> NumExpansions) {
  ID.AddPointer(Pattern.getAsOpaquePtr());
  ID.AddBoolean(NumExpansions.hasValue());
  if (NumExpansions)
    ID.AddInteger(*NumExpansions);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == PackExpansion;
}
5680};

5682/// This class wraps the list of protocol qualifiers. For types that can
5683/// take ObjC protocol qualifers, they can subclass this class.
5684template <class T>
5685class ObjCProtocolQualifiers {
5686protected:
ObjCProtocolQualifiers() = default;

ObjCProtocolDecl * const *getProtocolStorage() const {
  return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
}

ObjCProtocolDecl **getProtocolStorage() {
  return static_cast<T*>(this)->getProtocolStorageImpl();
}

void setNumProtocols(unsigned N) {
  static_cast<T*>(this)->setNumProtocolsImpl(N);
}

void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
  setNumProtocols(protocols.size());
  assert(getNumProtocols() == protocols.size() &&(static_cast<void> (0))
         "bitfield overflow in protocol count")(static_cast<void> (0));
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5710public:
using qual_iterator = ObjCProtocolDecl * const *;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
qual_iterator qual_begin() const { return getProtocolStorage(); }
qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }

bool qual_empty() const { return getNumProtocols() == 0; }

/// Return the number of qualifying protocols in this type, or 0 if
/// there are none.
unsigned getNumProtocols() const {
  return static_cast<const T*>(this)->getNumProtocolsImpl();
}

/// Fetch a protocol by index.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  assert(I < getNumProtocols() && "Out-of-range protocol access")(static_cast<void> (0));
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5736};

5738/// Represents a type parameter type in Objective C. It can take
5739/// a list of protocols.
5740class ObjCTypeParamType : public Type,
                        public ObjCProtocolQualifiers<ObjCTypeParamType>,
                        public llvm::FoldingSetNode {
friend class ASTContext;
friend class ObjCProtocolQualifiers<ObjCTypeParamType>;

/// The number of protocols stored on this type.
unsigned NumProtocols : 6;

ObjCTypeParamDecl *OTPDecl;

/// The protocols are stored after the ObjCTypeParamType node. In the
/// canonical type, the list of protocols are sorted alphabetically
/// and uniqued.
ObjCProtocolDecl **getProtocolStorageImpl();

/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return NumProtocols;
}

void setNumProtocolsImpl(unsigned N) {
  NumProtocols = N;
}

ObjCTypeParamType(const ObjCTypeParamDecl *D,
                  QualType can,
                  ArrayRef<ObjCProtocolDecl *> protocols);

5770public:
bool isSugared() const { return true; }
QualType desugar() const { return getCanonicalTypeInternal(); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCTypeParam;
}

void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    const ObjCTypeParamDecl *OTPDecl,
                    QualType CanonicalType,
                    ArrayRef<ObjCProtocolDecl *> protocols);

ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
5785};

5787/// Represents a class type in Objective C.
5788///
5789/// Every Objective C type is a combination of a base type, a set of
5790/// type arguments (optional, for parameterized classes) and a list of
5791/// protocols.
5792///
5793/// Given the following declarations:
5794/// \code
5795///   \@class C<T>;
5796///   \@protocol P;
5797/// \endcode
5798///
5799/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5800/// with base C and no protocols.
5801///
5802/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5803/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5804/// protocol list.
5805/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5806/// and protocol list [P].
5807///
5808/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5809/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5810/// and no protocols.
5811///
5812/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5813/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5814/// this should get its own sugar class to better represent the source.
5815class ObjCObjectType : public Type,
                     public ObjCProtocolQualifiers<ObjCObjectType> {
friend class ObjCProtocolQualifiers<ObjCObjectType>;

// ObjCObjectType.NumTypeArgs - the number of type arguments stored
// after the ObjCObjectPointerType node.
// ObjCObjectType.NumProtocols - the number of protocols stored
// after the type arguments of ObjCObjectPointerType node.
//
// These protocols are those written directly on the type.  If
// protocol qualifiers ever become additive, the iterators will need
// to get kindof complicated.
//
// In the canonical object type, these are sorted alphabetically
// and uniqued.

/// Either a BuiltinType or an InterfaceType or sugar for either.
QualType BaseType;

/// Cached superclass type.
mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
  CachedSuperClassType;

QualType *getTypeArgStorage();
const QualType *getTypeArgStorage() const {
  return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
}

ObjCProtocolDecl **getProtocolStorageImpl();
/// Return the number of qualifying protocols in this interface type,
/// or 0 if there are none.
unsigned getNumProtocolsImpl() const {
  return ObjCObjectTypeBits.NumProtocols;
}
void setNumProtocolsImpl(unsigned N) {
  ObjCObjectTypeBits.NumProtocols = N;
}

5853protected:
enum Nonce_ObjCInterface { Nonce_ObjCInterface };

ObjCObjectType(QualType Canonical, QualType Base,
               ArrayRef<QualType> typeArgs,
               ArrayRef<ObjCProtocolDecl *> protocols,
               bool isKindOf);

ObjCObjectType(enum Nonce_ObjCInterface)
    : Type(ObjCInterface, QualType(), TypeDependence::None),
      BaseType(QualType(this_(), 0)) {
  ObjCObjectTypeBits.NumProtocols = 0;
  ObjCObjectTypeBits.NumTypeArgs = 0;
  ObjCObjectTypeBits.IsKindOf = 0;
}

void computeSuperClassTypeSlow() const;

5871public:
/// Gets the base type of this object type.  This is always (possibly
/// sugar for) one of:
///  - the 'id' builtin type (as opposed to the 'id' type visible to the
///    user, which is a typedef for an ObjCObjectPointerType)
///  - the 'Class' builtin type (same caveat)
///  - an ObjCObjectType (currently always an ObjCInterfaceType)
QualType getBaseType() const { return BaseType; }

bool isObjCId() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
}

bool isObjCClass() const {
  return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
}

bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
bool isObjCUnqualifiedIdOrClass() const {
  if (!qual_empty()) return false;
  if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
    return T->getKind() == BuiltinType::ObjCId ||
           T->getKind() == BuiltinType::ObjCClass;
  return false;
}
bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }

/// Gets the interface declaration for this object type, if the base type
/// really is an interface.
ObjCInterfaceDecl *getInterface() const;

/// Determine whether this object type is "specialized", meaning
/// that it has type arguments.
bool isSpecialized() const;

/// Determine whether this object type was written with type arguments.
bool isSpecializedAsWritten() const {
  return ObjCObjectTypeBits.NumTypeArgs > 0;
}

/// Determine whether this object type is "unspecialized", meaning
/// that it has no type arguments.
bool isUnspecialized() const { return !isSpecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments of this object type (semantically).
ArrayRef<QualType> getTypeArgs() const;

/// Retrieve the type arguments of this object type as they were
/// written.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return llvm::makeArrayRef(getTypeArgStorage(),
                            ObjCObjectTypeBits.NumTypeArgs);
}

/// Whether this is a "__kindof" type as written.
bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }

/// Whether this ia a "__kindof" type (semantically).
bool isKindOfType() const;

/// Retrieve the type of the superclass of this object type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// specialization of the superclass type. Produces a null type if
/// there is no superclass.
QualType getSuperClassType() const {
  if (!CachedSuperClassType.getInt())
    computeSuperClassTypeSlow();

  assert(CachedSuperClassType.getInt() && "Superclass not set?")(static_cast<void> (0));
  return QualType(CachedSuperClassType.getPointer(), 0);
}

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObject ||
         T->getTypeClass() == ObjCInterface;
}
5962};

5964/// A class providing a concrete implementation
5965/// of ObjCObjectType, so as to not increase the footprint of
5966/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5967/// system should not reference this type.
5968class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
friend class ASTContext;

// If anyone adds fields here, ObjCObjectType::getProtocolStorage()
// will need to be modified.

ObjCObjectTypeImpl(QualType Canonical, QualType Base,
                   ArrayRef<QualType> typeArgs,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   bool isKindOf)
    : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}

5980public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5987};

5989inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5991}

5993inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5996}

5998inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
6001}

6003/// Interfaces are the core concept in Objective-C for object oriented design.
6004/// They basically correspond to C++ classes.  There are two kinds of interface
6005/// types: normal interfaces like `NSString`, and qualified interfaces, which
6006/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6007///
6008/// ObjCInterfaceType guarantees the following properties when considered
6009/// as a subtype of its superclass, ObjCObjectType:
6010///   - There are no protocol qualifiers.  To reinforce this, code which
6011///     tries to invoke the protocol methods via an ObjCInterfaceType will
6012///     fail to compile.
6013///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
6014///     T->getBaseType() == QualType(T, 0).
6015class ObjCInterfaceType : public ObjCObjectType {
friend class ASTContext; // ASTContext creates these.
friend class ASTReader;
friend class ObjCInterfaceDecl;
template <class T> friend class serialization::AbstractTypeReader;

mutable ObjCInterfaceDecl *Decl;

ObjCInterfaceType(const ObjCInterfaceDecl *D)
    : ObjCObjectType(Nonce_ObjCInterface),
      Decl(const_cast<ObjCInterfaceDecl*>(D)) {}

6027public:
/// Get the declaration of this interface.
ObjCInterfaceDecl *getDecl() const { return Decl; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCInterface;
}

// Nonsense to "hide" certain members of ObjCObjectType within this
// class.  People asking for protocols on an ObjCInterfaceType are
// not going to get what they want: ObjCInterfaceTypes are
// guaranteed to have no protocols.
enum {
  qual_iterator,
  qual_begin,
  qual_end,
  getNumProtocols,
  getProtocol
};
6049};

6051inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
QualType baseType = getBaseType();
while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
  if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
    return T->getDecl();

  baseType = ObjT->getBaseType();
}

return nullptr;
6061}

6063/// Represents a pointer to an Objective C object.
6064///
6065/// These are constructed from pointer declarators when the pointee type is
6066/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
6067/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6068/// and 'Class<P>' are translated into these.
6069///
6070/// Pointers to pointers to Objective C objects are still PointerTypes;
6071/// only the first level of pointer gets it own type implementation.
6072class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType PointeeType;

ObjCObjectPointerType(QualType Canonical, QualType Pointee)
    : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
      PointeeType(Pointee) {}

6081public:
/// Gets the type pointed to by this ObjC pointer.
/// The result will always be an ObjCObjectType or sugar thereof.
QualType getPointeeType() const { return PointeeType; }

/// Gets the type pointed to by this ObjC pointer.  Always returns non-null.
///
/// This method is equivalent to getPointeeType() except that
/// it discards any typedefs (or other sugar) between this
/// type and the "outermost" object type.  So for:
/// \code
///   \@class A; \@protocol P; \@protocol Q;
///   typedef A<P> AP;
///   typedef A A1;
///   typedef A1<P> A1P;
///   typedef A1P<Q> A1PQ;
/// \endcode
/// For 'A*', getObjectType() will return 'A'.
/// For 'A<P>*', getObjectType() will return 'A<P>'.
/// For 'AP*', getObjectType() will return 'A<P>'.
/// For 'A1*', getObjectType() will return 'A'.
/// For 'A1<P>*', getObjectType() will return 'A1<P>'.
/// For 'A1P*', getObjectType() will return 'A1<P>'.
/// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
///   adding protocols to a protocol-qualified base discards the
///   old qualifiers (for now).  But if it didn't, getObjectType()
///   would return 'A1P<Q>' (and we'd have to make iterating over
///   qualifiers more complicated).
const ObjCObjectType *getObjectType() const {
  return PointeeType->castAs<ObjCObjectType>();
}

/// If this pointer points to an Objective C
/// \@interface type, gets the type for that interface.  Any protocol
/// qualifiers on the interface are ignored.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
const ObjCInterfaceType *getInterfaceType() const;

/// If this pointer points to an Objective \@interface
/// type, gets the declaration for that interface.
///
/// \return null if the base type for this pointer is 'id' or 'Class'
ObjCInterfaceDecl *getInterfaceDecl() const {
  return getObjectType()->getInterface();
}

/// True if this is equivalent to the 'id' type, i.e. if
/// its object type is the primitive 'id' type with no protocols.
bool isObjCIdType() const {
  return getObjectType()->isObjCUnqualifiedId();
}

/// True if this is equivalent to the 'Class' type,
/// i.e. if its object tive is the primitive 'Class' type with no protocols.
bool isObjCClassType() const {
  return getObjectType()->isObjCUnqualifiedClass();
}

/// True if this is equivalent to the 'id' or 'Class' type,
bool isObjCIdOrClassType() const {
  return getObjectType()->isObjCUnqualifiedIdOrClass();
}

/// True if this is equivalent to 'id<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedIdType() const {
  return getObjectType()->isObjCQualifiedId();
}

/// True if this is equivalent to 'Class<P>' for some non-empty set of
/// protocols.
bool isObjCQualifiedClassType() const {
  return getObjectType()->isObjCQualifiedClass();
}

/// Whether this is a "__kindof" type.
bool isKindOfType() const { return getObjectType()->isKindOfType(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecialized() const { return getObjectType()->isSpecialized(); }

/// Whether this type is specialized, meaning that it has type arguments.
bool isSpecializedAsWritten() const {
  return getObjectType()->isSpecializedAsWritten();
}

/// Whether this type is unspecialized, meaning that is has no type arguments.
bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }

/// Determine whether this object type is "unspecialized" as
/// written, meaning that it has no type arguments.
bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgs() const {
  return getObjectType()->getTypeArgs();
}

/// Retrieve the type arguments for this type.
ArrayRef<QualType> getTypeArgsAsWritten() const {
  return getObjectType()->getTypeArgsAsWritten();
}

/// An iterator over the qualifiers on the object type.  Provided
/// for convenience.  This will always iterate over the full set of
/// protocols on a type, not just those provided directly.
using qual_iterator = ObjCObjectType::qual_iterator;
using qual_range = llvm::iterator_range<qual_iterator>;

qual_range quals() const { return qual_range(qual_begin(), qual_end()); }

qual_iterator qual_begin() const {
  return getObjectType()->qual_begin();
}

qual_iterator qual_end() const {
  return getObjectType()->qual_end();
}

bool qual_empty() const { return getObjectType()->qual_empty(); }

/// Return the number of qualifying protocols on the object type.
unsigned getNumProtocols() const {
  return getObjectType()->getNumProtocols();
}

/// Retrieve a qualifying protocol by index on the object type.
ObjCProtocolDecl *getProtocol(unsigned I) const {
  return getObjectType()->getProtocol(I);
}

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

/// Retrieve the type of the superclass of this object pointer type.
///
/// This operation substitutes any type arguments into the
/// superclass of the current class type, potentially producing a
/// pointer to a specialization of the superclass type. Produces a
/// null type if there is no superclass.
QualType getSuperClassType() const;

/// Strip off the Objective-C "kindof" type and (with it) any
/// protocol qualifiers.
const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
                               const ASTContext &ctx) const;

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getPointeeType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == ObjCObjectPointer;
}
6240};

6242class AtomicType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ValueType;

AtomicType(QualType ValTy, QualType Canonical)
    : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}

6250public:
/// Gets the type contained by this atomic type, i.e.
/// the type returned by performing an atomic load of this atomic type.
QualType getValueType() const { return ValueType; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getValueType());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
  ID.AddPointer(T.getAsOpaquePtr());
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Atomic;
}
6269};

6271/// PipeType - OpenCL20.
6272class PipeType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these.

QualType ElementType;
bool isRead;

PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
    : Type(Pipe, CanonicalPtr, elemType->getDependence()),
      ElementType(elemType), isRead(isRead) {}

6282public:
QualType getElementType() const { return ElementType; }

bool isSugared() const { return false; }

QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, getElementType(), isReadOnly());
}

static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
  ID.AddPointer(T.getAsOpaquePtr());
  ID.AddBoolean(isRead);
}

static bool classof(const Type *T) {
  return T->getTypeClass() == Pipe;
}

bool isReadOnly() const { return isRead; }
6303};

6305/// A fixed int type of a specified bitwidth.
6306class ExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
unsigned IsUnsigned : 1;
unsigned NumBits : 24;

6311protected:
ExtIntType(bool isUnsigned, unsigned NumBits);

6314public:
bool isUnsigned() const { return IsUnsigned; }
bool isSigned() const { return !IsUnsigned; }
unsigned getNumBits() const { return NumBits; }

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, isUnsigned(), getNumBits());
}

static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
                    unsigned NumBits) {
  ID.AddBoolean(IsUnsigned);
  ID.AddInteger(NumBits);
}

static bool classof(const Type *T) { return T->getTypeClass() == ExtInt; }
6333};

6335class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
const ASTContext &Context;
llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;

6340protected:
DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
                    Expr *NumBits);

6344public:
bool isUnsigned() const;
bool isSigned() const { return !isUnsigned(); }
Expr *getNumBitsExpr() const;

bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

void Profile(llvm::FoldingSetNodeID &ID) {
  Profile(ID, Context, isUnsigned(), getNumBitsExpr());
}
static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                    bool IsUnsigned, Expr *NumBitsExpr);

static bool classof(const Type *T) {
  return T->getTypeClass() == DependentExtInt;
}
6361};

6363/// A qualifier set is used to build a set of qualifiers.
6364class QualifierCollector : public Qualifiers {
6365public:
QualifierCollector(Qualifiers Qs = Qualifiers()) : Qualifiers(Qs) {}

/// Collect any qualifiers on the given type and return an
/// unqualified type.  The qualifiers are assumed to be consistent
/// with those already in the type.
const Type *strip(QualType type) {
  addFastQualifiers(type.getLocalFastQualifiers());
  if (!type.hasLocalNonFastQualifiers())
    return type.getTypePtrUnsafe();

  const ExtQuals *extQuals = type.getExtQualsUnsafe();
  addConsistentQualifiers(extQuals->getQualifiers());
  return extQuals->getBaseType();
}

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, QualType QT) const;

/// Apply the collected qualifiers to the given type.
QualType apply(const ASTContext &Context, const Type* T) const;
6386};

6388/// A container of type source information.
6389///
6390/// A client can read the relevant info using TypeLoc wrappers, e.g:
6391/// @code
6392/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6393/// TL.getBeginLoc().print(OS, SrcMgr);
6394/// @endcode
6395class alignas(8) TypeSourceInfo {
// Contains a memory block after the class, used for type source information,
// allocated by ASTContext.
friend class ASTContext;

QualType Ty;

TypeSourceInfo(QualType ty) : Ty(ty) {}

6404public:
/// Return the type wrapped by this type source info.
QualType getType() const { return Ty; }

/// Return the TypeLoc wrapper for the type source info.
TypeLoc getTypeLoc() const; // implemented in TypeLoc.h

/// Override the type stored in this TypeSourceInfo. Use with caution!
void overrideType(QualType T) { Ty = T; }
6413};

6415// Inline function definitions.

6417inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6422}

6424inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6426}

6428inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6430}

6432inline SplitQualType QualType::split() const {
if (!hasLocalNonFastQualifiers())
  return SplitQualType(getTypePtrUnsafe(),
                       Qualifiers::fromFastMask(getLocalFastQualifiers()));

const ExtQuals *eq = getExtQualsUnsafe();
Qualifiers qs = eq->getQualifiers();
qs.addFastQualifiers(getLocalFastQualifiers());
return SplitQualType(eq->getBaseType(), qs);
6441}

6443inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6449}

6451inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6455}

6457inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6461}

6463inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6466}

6468inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6470}

6472inline bool QualType::isCanonicalAsParam() const {
if (!isCanonical()) return false;
if (hasLocalQualifiers()) return false;

const Type *T = getTypePtr();
if (T->isVariablyModifiedType() && T->hasSizedVLAType())
  return false;

return !isa<FunctionType>(T) && !isa<ArrayType>(T);
6481}

6483inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6486}

6488inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6491}


6494inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6497}

6499inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6502}

6504inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6509}

6511inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6516}

6518inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6520}

6522inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6524}

6526inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6528}

6530inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")(static_cast<void> (0));
static_assert((int)Qualifiers::CVRMask == (int)Qualifiers::FastMask,
              "Fast bits differ from CVR bits!");

// Fast path: we don't need to touch the slow qualifiers.
removeLocalFastQualifiers(Mask);
6537}

6539/// Check if this type has any address space qualifier.
6540inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6542}

6544/// Return the address space of this type.
6545inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6547}

6549/// Return the gc attribute of this type.
6550inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6552}

6554inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6558}

6560inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6564}

6566inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6570}

6572inline FunctionType::ExtInfo getFunctionExtInfo(const Type &t) {
if (const auto *PT = t.getAs<PointerType>()) {
  if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
    return FT->getExtInfo();
} else if (const auto *FT = t.getAs<FunctionType>())
  return FT->getExtInfo();

return FunctionType::ExtInfo();
6580}

6582inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6584}

6586/// Determine whether this type is more
6587/// qualified than the Other type. For example, "const volatile int"
6588/// is more qualified than "const int", "volatile int", and
6589/// "int". However, it is not more qualified than "const volatile
6590/// int".
6591inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6595}

6597/// Determine whether this type is at last
6598/// as qualified as the Other type. For example, "const volatile
6599/// int" is at least as qualified as "const int", "volatile int",
6600/// "int", and "const volatile int".
6601inline bool QualType::isAtLeastAsQualifiedAs(QualType other) const {
Qualifiers OtherQuals = other.getQualifiers();

// Ignore __unaligned qualifier if this type is a void.
if (getUnqualifiedType()->isVoidType())
  OtherQuals.removeUnaligned();

return getQualifiers().compatiblyIncludes(OtherQuals);
6609}

6611/// If Type is a reference type (e.g., const
6612/// int&), returns the type that the reference refers to ("const
6613/// int"). Otherwise, returns the type itself. This routine is used
6614/// throughout Sema to implement C++ 5p6:
6615///
6616///   If an expression initially has the type "reference to T" (8.3.2,
6617///   8.5.3), the type is adjusted to "T" prior to any further
6618///   analysis, the expression designates the object or function
6619///   denoted by the reference, and the expression is an lvalue.
6620inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6625}

6627inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6630}

6632/// Tests whether the type is categorized as a fundamental type.
6633///
6634/// \returns True for types specified in C++0x [basic.fundamental].
6635inline bool Type::isFundamentalType() const {
return isVoidType() ||
       isNullPtrType() ||
       // FIXME: It's really annoying that we don't have an
       // 'isArithmeticType()' which agrees with the standard definition.
       (isArithmeticType() && !isEnumeralType());
6641}

6643/// Tests whether the type is categorized as a compound type.
6644///
6645/// \returns True for types specified in C++0x [basic.compound].
6646inline bool Type::isCompoundType() const {
// C++0x [basic.compound]p1:
//   Compound types can be constructed in the following ways:
//    -- arrays of objects of a given type [...];
return isArrayType() ||
//    -- functions, which have parameters of given types [...];
       isFunctionType() ||
//    -- pointers to void or objects or functions [...];
       isPointerType() ||
//    -- references to objects or functions of a given type. [...]
       isReferenceType() ||
//    -- classes containing a sequence of objects of various types, [...];
       isRecordType() ||
//    -- unions, which are classes capable of containing objects of different
//               types at different times;
       isUnionType() ||
//    -- enumerations, which comprise a set of named constant values. [...];
       isEnumeralType() ||
//    -- pointers to non-static class members, [...].
       isMemberPointerType();
6666}

6668inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6670}

6672inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6674}

6676inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6678}

6680inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6682}

6684inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6686}

6688inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6690}

6692inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6694}

6696inline bool Type::isObjectPointerType() const {
// Note: an "object pointer type" is not the same thing as a pointer to an
// object type; rather, it is a pointer to an object type or a pointer to cv
// void.
if (const auto *T = getAs<PointerType>())
  return !T->getPointeeType()->isFunctionType();
else
  return false;
6704}

6706inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6711}

6713inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6718}

6720inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6722}

6724inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6729}

6731inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6736}

6738inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6740}

6742inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6744}

6746inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6748}

6750inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6752}

6754inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6756}

6758inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6760}

6762inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6764}

6766inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
53
←
Assuming field 'CanonicalType' is a 'EnumType'→
54
←
Returning the value 1, which participates in a condition later→
76
←
Assuming field 'CanonicalType' is a 'EnumType'→
77
←
Returning the value 1, which participates in a condition later→
6768}

6770inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6772}

6774inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
122
←
Assuming field 'CanonicalType' is not a 'VectorType'→
123
←
Returning zero, which participates in a condition later→
6776}

6778inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
118
←
Assuming field 'CanonicalType' is not a 'ExtVectorType'→
119
←
Returning zero, which participates in a condition later→
6780}

6782inline bool Type::isMatrixType() const {
return isa<MatrixType>(CanonicalType);
6784}

6786inline bool Type::isConstantMatrixType() const {
return isa<ConstantMatrixType>(CanonicalType);
6788}

6790inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6792}

6794inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6796}

6798inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6800}

6802inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6805}

6807inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6809}

6811inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6813}

6815inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6819}

6821inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6825}

6827inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6831}

6833inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6837}

6839inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6843}

6845inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6847}

6849inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6851}

6853#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6857#include "clang/Basic/OpenCLImageTypes.def"

6859inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6861}

6863inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6865}

6867inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6869}

6871inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6873}

6875inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6877}

6879inline bool Type::isImageType() const {
6880#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6882#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6884}

6886inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6888}

6890inline bool Type::isExtIntType() const {
return isa<ExtIntType>(CanonicalType);
6892}

6894#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6898#include "clang/Basic/OpenCLExtensionTypes.def"

6900inline bool Type::isOCLIntelSubgroupAVCType() const {
6901#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6904#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6906}

6908inline bool Type::isOCLExtOpaqueType() const {
6909#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6911#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6913}

6915inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6918}

6920inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6922}

6924inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>()) {
  return BT->getKind() == static_cast<BuiltinType::Kind>(K);
}
return false;
6929}

6931inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6935}

6937inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6942}

6944inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))(static_cast<void> (0));
return isSpecificBuiltinType(K);
6947}

6949inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6953}

6955inline bool Type::isVoidType() const {
return isSpecificBuiltinType(BuiltinType::Void);
6957}

6959inline bool Type::isHalfType() const {
// FIXME: Should we allow complex __fp16? Probably not.
return isSpecificBuiltinType(BuiltinType::Half);
6962}

6964inline bool Type::isFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::Float16);
6966}

6968inline bool Type::isBFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::BFloat16);
6970}

6972inline bool Type::isFloat128Type() const {
return isSpecificBuiltinType(BuiltinType::Float128);
6974}

6976inline bool Type::isNullPtrType() const {
return isSpecificBuiltinType(BuiltinType::NullPtr);
6978}

6980bool IsEnumDeclComplete(EnumDecl *);
6981bool IsEnumDeclScoped(EnumDecl *);

6983inline bool Type::isIntegerType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
  // Incomplete enum types are not treated as integer types.
  // FIXME: In C++, enum types are never integer types.
  return IsEnumDeclComplete(ET->getDecl()) &&
    !IsEnumDeclScoped(ET->getDecl());
}
return isExtIntType();
6994}

6996inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7002}

7004inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
7006}

7008inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7014}

7016inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
7018}

7020inline bool Type::isSignedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return ((BT->getKind() >= BuiltinType::ShortAccum &&
           BT->getKind() <= BuiltinType::LongAccum) ||
          (BT->getKind() >= BuiltinType::ShortFract &&
           BT->getKind() <= BuiltinType::LongFract) ||
          (BT->getKind() >= BuiltinType::SatShortAccum &&
           BT->getKind() <= BuiltinType::SatLongAccum) ||
          (BT->getKind() >= BuiltinType::SatShortFract &&
           BT->getKind() <= BuiltinType::SatLongFract));
}
return false;
7032}

7034inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
7036}

7038inline bool Type::isScalarType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() > BuiltinType::Void &&
         BT->getKind() <= BuiltinType::NullPtr;
if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
  // Enums are scalar types, but only if they are defined.  Incomplete enums
  // are not treated as scalar types.
  return IsEnumDeclComplete(ET->getDecl());
return isa<PointerType>(CanonicalType) ||
       isa<BlockPointerType>(CanonicalType) ||
       isa<MemberPointerType>(CanonicalType) ||
       isa<ComplexType>(CanonicalType) ||
       isa<ObjCObjectPointerType>(CanonicalType) ||
       isExtIntType();
7052}

7054inline bool Type::isIntegralOrEnumerationType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() >= BuiltinType::Bool &&
         BT->getKind() <= BuiltinType::Int128;

// Check for a complete enum type; incomplete enum types are not properly an
// enumeration type in the sense required here.
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
  return IsEnumDeclComplete(ET->getDecl());

return isExtIntType();
7065}

7067inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
7071}

7073inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
7076}

7078/// Determines whether this is a type for which one can define
7079/// an overloaded operator.
7080inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
7082}

7084/// Determines whether this type is written as a typedef-name.
7085inline bool Type::isTypedefNameType() const {
if (getAs<TypedefType>())
  return true;
if (auto *TST = getAs<TemplateSpecializationType>())
  return TST->isTypeAlias();
return false;
7091}

7093/// Determines whether this type can decay to a pointer type.
7094inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
7096}

7098inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
7101}

7103inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
7105}

7107inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
7112}

7114inline const Type *Type::getPointeeOrArrayElementType() const {
const Type *type = this;
if (type->isAnyPointerType())
  return type->getPointeeType().getTypePtr();
else if (type->isArrayType())
  return type->getBaseElementTypeUnsafe();
return type;
7121}
7122/// Insertion operator for partial diagnostics. This allows sending adress
7123/// spaces into a diagnostic with <<.
7124inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
7129}

7131/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7132/// into a diagnostic with <<.
7133inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
7138}

7140/// Insertion operator for partial diagnostics.  This allows sending QualType's
7141/// into a diagnostic with <<.
7142inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
7147}

7149// Helper class template that is used by Type::getAs to ensure that one does
7150// not try to look through a qualified type to get to an array type.
7151template <typename T>
7152using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

7156// Member-template getAs<specific type>'.
7157template <typename T> const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with getAs!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
7172}

7174template <typename T> const T *Type::getAsAdjusted() const {
static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");

// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
  return Ty;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
  return nullptr;

// Strip off type adjustments that do not modify the underlying nature of the
// type.
const Type *Ty = this;
while (Ty) {
  if (const auto *A = dyn_cast<AttributedType>(Ty))
    Ty = A->getModifiedType().getTypePtr();
  else if (const auto *E = dyn_cast<ElaboratedType>(Ty))
    Ty = E->desugar().getTypePtr();
  else if (const auto *P = dyn_cast<ParenType>(Ty))
    Ty = P->desugar().getTypePtr();
  else if (const auto *A = dyn_cast<AdjustedType>(Ty))
    Ty = A->desugar().getTypePtr();
  else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
    Ty = M->desugar().getTypePtr();
  else
    break;
}

// Just because the canonical type is correct does not mean we can use cast<>,
// since we may not have stripped off all the sugar down to the base type.
return dyn_cast<T>(Ty);
7206}

7208inline const ArrayType *Type::getAsArrayTypeUnsafe() const {
// If this is directly an array type, return it.
if (const auto *arr = dyn_cast<ArrayType>(this))
  return arr;

// If the canonical form of this type isn't the right kind, reject it.
if (!isa<ArrayType>(CanonicalType))
  return nullptr;

// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<ArrayType>(getUnqualifiedDesugaredType());
7220}

7222template <typename T> const T *Type::castAs() const {
static_assert(!TypeIsArrayType<T>::value,
              "ArrayType cannot be used with castAs!");

if (const auto *ty = dyn_cast<T>(this)) return ty;
assert(isa<T>(CanonicalType))(static_cast<void> (0));
return cast<T>(getUnqualifiedDesugaredType());
7229}

7231inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))(static_cast<void> (0));
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7235}

7237DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7240#ifndef NDEBUG1
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))(static_cast<void> (0));
7244#endif
7245}

7247QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7251}

7253// Get the decimal string representation of a fixed point type, represented
7254// as a scaled integer.
7255// TODO: At some point, we should change the arguments to instead just accept an
7256// APFixedPoint instead of APSInt and scale.
7257void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7260} // namespace clang

7262#endif // LLVM_CLANG_AST_TYPE_H

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include/clang/AST/Expr.h

1//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the Expr interface and subclasses.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_AST_EXPR_H
14#define LLVM_CLANG_AST_EXPR_H

16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTVector.h"
18#include "clang/AST/ComputeDependence.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclAccessPair.h"
21#include "clang/AST/DependenceFlags.h"
22#include "clang/AST/OperationKinds.h"
23#include "clang/AST/Stmt.h"
24#include "clang/AST/TemplateBase.h"
25#include "clang/AST/Type.h"
26#include "clang/Basic/CharInfo.h"
27#include "clang/Basic/LangOptions.h"
28#include "clang/Basic/SyncScope.h"
29#include "clang/Basic/TypeTraits.h"
30#include "llvm/ADT/APFloat.h"
31#include "llvm/ADT/APSInt.h"
32#include "llvm/ADT/SmallVector.h"
33#include "llvm/ADT/StringRef.h"
34#include "llvm/ADT/iterator.h"
35#include "llvm/ADT/iterator_range.h"
36#include "llvm/Support/AtomicOrdering.h"
37#include "llvm/Support/Compiler.h"
38#include "llvm/Support/TrailingObjects.h"

40namespace clang {
class APValue;
class ASTContext;
class BlockDecl;
class CXXBaseSpecifier;
class CXXMemberCallExpr;
class CXXOperatorCallExpr;
class CastExpr;
class Decl;
class IdentifierInfo;
class MaterializeTemporaryExpr;
class NamedDecl;
class ObjCPropertyRefExpr;
class OpaqueValueExpr;
class ParmVarDecl;
class StringLiteral;
class TargetInfo;
class ValueDecl;

59/// A simple array of base specifiers.
60typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;

62/// An adjustment to be made to the temporary created when emitting a
63/// reference binding, which accesses a particular subobject of that temporary.
64struct SubobjectAdjustment {
enum {
  DerivedToBaseAdjustment,
  FieldAdjustment,
  MemberPointerAdjustment
} Kind;

struct DTB {
  const CastExpr *BasePath;
  const CXXRecordDecl *DerivedClass;
};

struct P {
  const MemberPointerType *MPT;
  Expr *RHS;
};

union {
  struct DTB DerivedToBase;
  FieldDecl *Field;
  struct P Ptr;
};

SubobjectAdjustment(const CastExpr *BasePath,
                    const CXXRecordDecl *DerivedClass)
  : Kind(DerivedToBaseAdjustment) {
  DerivedToBase.BasePath = BasePath;
  DerivedToBase.DerivedClass = DerivedClass;
}

SubobjectAdjustment(FieldDecl *Field)
  : Kind(FieldAdjustment) {
  this->Field = Field;
}

SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
  : Kind(MemberPointerAdjustment) {
  this->Ptr.MPT = MPT;
  this->Ptr.RHS = RHS;
}
104};

106/// This represents one expression.  Note that Expr's are subclasses of Stmt.
107/// This allows an expression to be transparently used any place a Stmt is
108/// required.
109class Expr : public ValueStmt {
QualType TR;

112public:
Expr() = delete;
Expr(const Expr&) = delete;
Expr(Expr &&) = delete;
Expr &operator=(const Expr&) = delete;
Expr &operator=(Expr&&) = delete;

119protected:
Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK)
    : ValueStmt(SC) {
  ExprBits.Dependent = 0;
  ExprBits.ValueKind = VK;
  ExprBits.ObjectKind = OK;
  assert(ExprBits.ObjectKind == OK && "truncated kind")(static_cast<void> (0));
  setType(T);
}

/// Construct an empty expression.
explicit Expr(StmtClass SC, EmptyShell) : ValueStmt(SC) { }

/// Each concrete expr subclass is expected to compute its dependence and call
/// this in the constructor.
void setDependence(ExprDependence Deps) {
  ExprBits.Dependent = static_cast<unsigned>(Deps);
}
friend class ASTImporter; // Sets dependence dircetly.
friend class ASTStmtReader; // Sets dependence dircetly.

140public:
QualType getType() const { return TR; }
void setType(QualType t) {
  // In C++, the type of an expression is always adjusted so that it
  // will not have reference type (C++ [expr]p6). Use
  // QualType::getNonReferenceType() to retrieve the non-reference
  // type. Additionally, inspect Expr::isLvalue to determine whether
  // an expression that is adjusted in this manner should be
  // considered an lvalue.
  assert((t.isNull() || !t->isReferenceType()) &&(static_cast<void> (0))
         "Expressions can't have reference type")(static_cast<void> (0));

  TR = t;
}

ExprDependence getDependence() const {
  return static_cast<ExprDependence>(ExprBits.Dependent);
}

/// Determines whether the value of this expression depends on
///   - a template parameter (C++ [temp.dep.constexpr])
///   - or an error, whose resolution is unknown
///
/// For example, the array bound of "Chars" in the following example is
/// value-dependent.
/// @code
/// template<int Size, char (&Chars)[Size]> struct meta_string;
/// @endcode
bool isValueDependent() const {
  return static_cast<bool>(getDependence() & ExprDependence::Value);
}

/// Determines whether the type of this expression depends on
///   - a template paramter (C++ [temp.dep.expr], which means that its type
///     could change from one template instantiation to the next)
///   - or an error
///
/// For example, the expressions "x" and "x + y" are type-dependent in
/// the following code, but "y" is not type-dependent:
/// @code
/// template<typename T>
/// void add(T x, int y) {
///   x + y;
/// }
/// @endcode
bool isTypeDependent() const {
  return static_cast<bool>(getDependence() & ExprDependence::Type);
}

/// Whether this expression is instantiation-dependent, meaning that
/// it depends in some way on
///    - a template parameter (even if neither its type nor (constant) value
///      can change due to the template instantiation)
///    - or an error
///
/// In the following example, the expression \c sizeof(sizeof(T() + T())) is
/// instantiation-dependent (since it involves a template parameter \c T), but
/// is neither type- nor value-dependent, since the type of the inner
/// \c sizeof is known (\c std::size_t) and therefore the size of the outer
/// \c sizeof is known.
///
/// \code
/// template<typename T>
/// void f(T x, T y) {
///   sizeof(sizeof(T() + T());
/// }
/// \endcode
///
/// \code
/// void func(int) {
///   func(); // the expression is instantiation-dependent, because it depends
///           // on an error.
/// }
/// \endcode
bool isInstantiationDependent() const {
  return static_cast<bool>(getDependence() & ExprDependence::Instantiation);
}

/// Whether this expression contains an unexpanded parameter
/// pack (for C++11 variadic templates).
///
/// Given the following function template:
///
/// \code
/// template<typename F, typename ...Types>
/// void forward(const F &f, Types &&...args) {
///   f(static_cast<Types&&>(args)...);
/// }
/// \endcode
///
/// The expressions \c args and \c static_cast<Types&&>(args) both
/// contain parameter packs.
bool containsUnexpandedParameterPack() const {
  return static_cast<bool>(getDependence() & ExprDependence::UnexpandedPack);
}

/// Whether this expression contains subexpressions which had errors, e.g. a
/// TypoExpr.
bool containsErrors() const {
  return static_cast<bool>(getDependence() & ExprDependence::Error);
}

/// getExprLoc - Return the preferred location for the arrow when diagnosing
/// a problem with a generic expression.
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__));

/// Determine whether an lvalue-to-rvalue conversion should implicitly be
/// applied to this expression if it appears as a discarded-value expression
/// in C++11 onwards. This applies to certain forms of volatile glvalues.
bool isReadIfDiscardedInCPlusPlus11() const;

/// isUnusedResultAWarning - Return true if this immediate expression should
/// be warned about if the result is unused.  If so, fill in expr, location,
/// and ranges with expr to warn on and source locations/ranges appropriate
/// for a warning.
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,
                            SourceRange &R1, SourceRange &R2,
                            ASTContext &Ctx) const;

/// isLValue - True if this expression is an "l-value" according to
/// the rules of the current language.  C and C++ give somewhat
/// different rules for this concept, but in general, the result of
/// an l-value expression identifies a specific object whereas the
/// result of an r-value expression is a value detached from any
/// specific storage.
///
/// C++11 divides the concept of "r-value" into pure r-values
/// ("pr-values") and so-called expiring values ("x-values"), which
/// identify specific objects that can be safely cannibalized for
/// their resources.
bool isLValue() const { return getValueKind() == VK_LValue; }
63
←
Assuming the condition is false→
64
←
Returning zero, which participates in a condition later→
bool isPRValue() const { return getValueKind() == VK_PRValue; }
bool isXValue() const { return getValueKind() == VK_XValue; }
bool isGLValue() const { return getValueKind() != VK_PRValue; }

enum LValueClassification {
  LV_Valid,
  LV_NotObjectType,
  LV_IncompleteVoidType,
  LV_DuplicateVectorComponents,
  LV_InvalidExpression,
  LV_InvalidMessageExpression,
  LV_MemberFunction,
  LV_SubObjCPropertySetting,
  LV_ClassTemporary,
  LV_ArrayTemporary
};
/// Reasons why an expression might not be an l-value.
LValueClassification ClassifyLValue(ASTContext &Ctx) const;

enum isModifiableLvalueResult {
  MLV_Valid,
  MLV_NotObjectType,
  MLV_IncompleteVoidType,
  MLV_DuplicateVectorComponents,
  MLV_InvalidExpression,
  MLV_LValueCast,           // Specialized form of MLV_InvalidExpression.
  MLV_IncompleteType,
  MLV_ConstQualified,
  MLV_ConstQualifiedField,
  MLV_ConstAddrSpace,
  MLV_ArrayType,
  MLV_NoSetterProperty,
  MLV_MemberFunction,
  MLV_SubObjCPropertySetting,
  MLV_InvalidMessageExpression,
  MLV_ClassTemporary,
  MLV_ArrayTemporary
};
/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
/// does not have an incomplete type, does not have a const-qualified type,
/// and if it is a structure or union, does not have any member (including,
/// recursively, any member or element of all contained aggregates or unions)
/// with a const-qualified type.
///
/// \param Loc [in,out] - A source location which *may* be filled
/// in with the location of the expression making this a
/// non-modifiable lvalue, if specified.
isModifiableLvalueResult
isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;

/// The return type of classify(). Represents the C++11 expression
///        taxonomy.
class Classification {
public:
  /// The various classification results. Most of these mean prvalue.
  enum Kinds {
    CL_LValue,
    CL_XValue,
    CL_Function, // Functions cannot be lvalues in C.
    CL_Void, // Void cannot be an lvalue in C.
    CL_AddressableVoid, // Void expression whose address can be taken in C.
    CL_DuplicateVectorComponents, // A vector shuffle with dupes.
    CL_MemberFunction, // An expression referring to a member function
    CL_SubObjCPropertySetting,
    CL_ClassTemporary, // A temporary of class type, or subobject thereof.
    CL_ArrayTemporary, // A temporary of array type.
    CL_ObjCMessageRValue, // ObjC message is an rvalue
    CL_PRValue // A prvalue for any other reason, of any other type
  };
  /// The results of modification testing.
  enum ModifiableType {
    CM_Untested, // testModifiable was false.
    CM_Modifiable,
    CM_RValue, // Not modifiable because it's an rvalue
    CM_Function, // Not modifiable because it's a function; C++ only
    CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext
    CM_NoSetterProperty,// Implicit assignment to ObjC property without setter
    CM_ConstQualified,
    CM_ConstQualifiedField,
    CM_ConstAddrSpace,
    CM_ArrayType,
    CM_IncompleteType
  };

private:
  friend class Expr;

  unsigned short Kind;
  unsigned short Modifiable;

  explicit Classification(Kinds k, ModifiableType m)
    : Kind(k), Modifiable(m)
  {}

public:
  Classification() {}

  Kinds getKind() const { return static_cast<Kinds>(Kind); }
  ModifiableType getModifiable() const {
    assert(Modifiable != CM_Untested && "Did not test for modifiability.")(static_cast<void> (0));
    return static_cast<ModifiableType>(Modifiable);
  }
  bool isLValue() const { return Kind == CL_LValue; }
  bool isXValue() const { return Kind == CL_XValue; }
  bool isGLValue() const { return Kind <= CL_XValue; }
  bool isPRValue() const { return Kind >= CL_Function; }
  bool isRValue() const { return Kind >= CL_XValue; }
  bool isModifiable() const { return getModifiable() == CM_Modifiable; }

  /// Create a simple, modifiably lvalue
  static Classification makeSimpleLValue() {
    return Classification(CL_LValue, CM_Modifiable);
  }

};
/// Classify - Classify this expression according to the C++11
///        expression taxonomy.
///
/// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the
/// old lvalue vs rvalue. This function determines the type of expression this
/// is. There are three expression types:
/// - lvalues are classical lvalues as in C++03.
/// - prvalues are equivalent to rvalues in C++03.
/// - xvalues are expressions yielding unnamed rvalue references, e.g. a
///   function returning an rvalue reference.
/// lvalues and xvalues are collectively referred to as glvalues, while
/// prvalues and xvalues together form rvalues.
Classification Classify(ASTContext &Ctx) const {
  return ClassifyImpl(Ctx, nullptr);
}

/// ClassifyModifiable - Classify this expression according to the
///        C++11 expression taxonomy, and see if it is valid on the left side
///        of an assignment.
///
/// This function extends classify in that it also tests whether the
/// expression is modifiable (C99 6.3.2.1p1).
/// \param Loc A source location that might be filled with a relevant location
///            if the expression is not modifiable.
Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const{
  return ClassifyImpl(Ctx, &Loc);
}

/// Returns the set of floating point options that apply to this expression.
/// Only meaningful for operations on floating point values.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const;

/// getValueKindForType - Given a formal return or parameter type,
/// give its value kind.
static ExprValueKind getValueKindForType(QualType T) {
  if (const ReferenceType *RT = T->getAs<ReferenceType>())
    return (isa<LValueReferenceType>(RT)
              ? VK_LValue
              : (RT->getPointeeType()->isFunctionType()
                   ? VK_LValue : VK_XValue));
  return VK_PRValue;
}

/// getValueKind - The value kind that this expression produces.
ExprValueKind getValueKind() const {
  return static_cast<ExprValueKind>(ExprBits.ValueKind);
}

/// getObjectKind - The object kind that this expression produces.
/// Object kinds are meaningful only for expressions that yield an
/// l-value or x-value.
ExprObjectKind getObjectKind() const {
  return static_cast<ExprObjectKind>(ExprBits.ObjectKind);
}

bool isOrdinaryOrBitFieldObject() const {
  ExprObjectKind OK = getObjectKind();
  return (OK == OK_Ordinary || OK == OK_BitField);
}

/// setValueKind - Set the value kind produced by this expression.
void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }

/// setObjectKind - Set the object kind produced by this expression.
void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }

452private:
Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;

455public:

/// Returns true if this expression is a gl-value that
/// potentially refers to a bit-field.
///
/// In C++, whether a gl-value refers to a bitfield is essentially
/// an aspect of the value-kind type system.
bool refersToBitField() const { return getObjectKind() == OK_BitField; }

/// If this expression refers to a bit-field, retrieve the
/// declaration of that bit-field.
///
/// Note that this returns a non-null pointer in subtly different
/// places than refersToBitField returns true.  In particular, this can
/// return a non-null pointer even for r-values loaded from
/// bit-fields, but it will return null for a conditional bit-field.
FieldDecl *getSourceBitField();

const FieldDecl *getSourceBitField() const {
  return const_cast<Expr*>(this)->getSourceBitField();
}

Decl *getReferencedDeclOfCallee();
const Decl *getReferencedDeclOfCallee() const {
  return const_cast<Expr*>(this)->getReferencedDeclOfCallee();
}

/// If this expression is an l-value for an Objective C
/// property, find the underlying property reference expression.
const ObjCPropertyRefExpr *getObjCProperty() const;

/// Check if this expression is the ObjC 'self' implicit parameter.
bool isObjCSelfExpr() const;

/// Returns whether this expression refers to a vector element.
bool refersToVectorElement() const;

/// Returns whether this expression refers to a matrix element.
bool refersToMatrixElement() const {
  return getObjectKind() == OK_MatrixComponent;
}

/// Returns whether this expression refers to a global register
/// variable.
bool refersToGlobalRegisterVar() const;

/// Returns whether this expression has a placeholder type.
bool hasPlaceholderType() const {
  return getType()->isPlaceholderType();
}

/// Returns whether this expression has a specific placeholder type.
bool hasPlaceholderType(BuiltinType::Kind K) const {
  assert(BuiltinType::isPlaceholderTypeKind(K))(static_cast<void> (0));
  if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))
    return BT->getKind() == K;
  return false;
}

/// isKnownToHaveBooleanValue - Return true if this is an integer expression
/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
/// but also int expressions which are produced by things like comparisons in
/// C.
///
/// \param Semantic If true, only return true for expressions that are known
/// to be semantically boolean, which might not be true even for expressions
/// that are known to evaluate to 0/1. For instance, reading an unsigned
/// bit-field with width '1' will evaluate to 0/1, but doesn't necessarily
/// semantically correspond to a bool.
bool isKnownToHaveBooleanValue(bool Semantic = true) const;

/// isIntegerConstantExpr - Return the value if this expression is a valid
/// integer constant expression.  If not a valid i-c-e, return None and fill
/// in Loc (if specified) with the location of the invalid expression.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
Optional<llvm::APSInt> getIntegerConstantExpr(const ASTContext &Ctx,
                                              SourceLocation *Loc = nullptr,
                                              bool isEvaluated = true) const;
bool isIntegerConstantExpr(const ASTContext &Ctx,
                           SourceLocation *Loc = nullptr) const;

/// isCXX98IntegralConstantExpr - Return true if this expression is an
/// integral constant expression in C++98. Can only be used in C++.
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;

/// isCXX11ConstantExpr - Return true if this expression is a constant
/// expression in C++11. Can only be used in C++.
///
/// Note: This does not perform the implicit conversions required by C++11
/// [expr.const]p5.
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,
                         SourceLocation *Loc = nullptr) const;

/// isPotentialConstantExpr - Return true if this function's definition
/// might be usable in a constant expression in C++11, if it were marked
/// constexpr. Return false if the function can never produce a constant
/// expression, along with diagnostics describing why not.
static bool isPotentialConstantExpr(const FunctionDecl *FD,
                                    SmallVectorImpl<
                                      PartialDiagnosticAt> &Diags);

/// isPotentialConstantExprUnevaluted - Return true if this expression might
/// be usable in a constant expression in C++11 in an unevaluated context, if
/// it were in function FD marked constexpr. Return false if the function can
/// never produce a constant expression, along with diagnostics describing
/// why not.
static bool isPotentialConstantExprUnevaluated(Expr *E,
                                               const FunctionDecl *FD,
                                               SmallVectorImpl<
                                                 PartialDiagnosticAt> &Diags);

/// isConstantInitializer - Returns true if this expression can be emitted to
/// IR as a constant, and thus can be used as a constant initializer in C.
/// If this expression is not constant and Culprit is non-null,
/// it is used to store the address of first non constant expr.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef,
                           const Expr **Culprit = nullptr) const;

/// EvalStatus is a struct with detailed info about an evaluation in progress.
struct EvalStatus {
  /// Whether the evaluated expression has side effects.
  /// For example, (f() && 0) can be folded, but it still has side effects.
  bool HasSideEffects;

  /// Whether the evaluation hit undefined behavior.
  /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.
  /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.
  bool HasUndefinedBehavior;

  /// Diag - If this is non-null, it will be filled in with a stack of notes
  /// indicating why evaluation failed (or why it failed to produce a constant
  /// expression).
  /// If the expression is unfoldable, the notes will indicate why it's not
  /// foldable. If the expression is foldable, but not a constant expression,
  /// the notes will describes why it isn't a constant expression. If the
  /// expression *is* a constant expression, no notes will be produced.
  SmallVectorImpl<PartialDiagnosticAt> *Diag;

  EvalStatus()
      : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {}

  // hasSideEffects - Return true if the evaluated expression has
  // side effects.
  bool hasSideEffects() const {
    return HasSideEffects;
  }
};

/// EvalResult is a struct with detailed info about an evaluated expression.
struct EvalResult : EvalStatus {
  /// Val - This is the value the expression can be folded to.
  APValue Val;

  // isGlobalLValue - Return true if the evaluated lvalue expression
  // is global.
  bool isGlobalLValue() const;
};

/// EvaluateAsRValue - Return true if this is a constant which we can fold to
/// an rvalue using any crazy technique (that has nothing to do with language
/// standards) that we want to, even if the expression has side-effects. If
/// this function returns true, it returns the folded constant in Result. If
/// the expression is a glvalue, an lvalue-to-rvalue conversion will be
/// applied.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,
                      bool InConstantContext = false) const;

/// EvaluateAsBooleanCondition - Return true if this is a constant
/// which we can fold and convert to a boolean condition using
/// any crazy technique that we want to, even if the expression has
/// side-effects.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
                                bool InConstantContext = false) const;

enum SideEffectsKind {
  SE_NoSideEffects,          ///< Strictly evaluate the expression.
  SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not
                             ///< arbitrary unmodeled side effects.
  SE_AllowSideEffects        ///< Allow any unmodeled side effect.
};

/// EvaluateAsInt - Return true if this is a constant which we can fold and
/// convert to an integer, using any crazy technique that we want to.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                   bool InConstantContext = false) const;

/// EvaluateAsFloat - Return true if this is a constant which we can fold and
/// convert to a floating point value, using any crazy technique that we
/// want to.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,
                     SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                     bool InConstantContext = false) const;

/// EvaluateAsFloat - Return true if this is a constant which we can fold and
/// convert to a fixed point value.
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
                          SideEffectsKind AllowSideEffects = SE_NoSideEffects,
                          bool InConstantContext = false) const;

/// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
/// constant folded without side-effects, but discard the result.
bool isEvaluatable(const ASTContext &Ctx,
                   SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

/// HasSideEffects - This routine returns true for all those expressions
/// which have any effect other than producing a value. Example is a function
/// call, volatile variable read, or throwing an exception. If
/// IncludePossibleEffects is false, this call treats certain expressions with
/// potential side effects (such as function call-like expressions,
/// instantiation-dependent expressions, or invocations from a macro) as not
/// having side effects.
bool HasSideEffects(const ASTContext &Ctx,
                    bool IncludePossibleEffects = true) const;

/// Determine whether this expression involves a call to any function
/// that is not trivial.
bool hasNonTrivialCall(const ASTContext &Ctx) const;

/// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded
/// integer. This must be called on an expression that constant folds to an
/// integer.
llvm::APSInt EvaluateKnownConstInt(
    const ASTContext &Ctx,
    SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

llvm::APSInt EvaluateKnownConstIntCheckOverflow(
    const ASTContext &Ctx,
    SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

void EvaluateForOverflow(const ASTContext &Ctx) const;

/// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an
/// lvalue with link time known address, with no side-effects.
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
                      bool InConstantContext = false) const;

/// EvaluateAsInitializer - Evaluate an expression as if it were the
/// initializer of the given declaration. Returns true if the initializer
/// can be folded to a constant, and produces any relevant notes. In C++11,
/// notes will be produced if the expression is not a constant expression.
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx,
                           const VarDecl *VD,
                           SmallVectorImpl<PartialDiagnosticAt> &Notes,
                           bool IsConstantInitializer) const;

/// EvaluateWithSubstitution - Evaluate an expression as if from the context
/// of a call to the given function with the given arguments, inside an
/// unevaluated context. Returns true if the expression could be folded to a
/// constant.
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
                              const FunctionDecl *Callee,
                              ArrayRef<const Expr*> Args,
                              const Expr *This = nullptr) const;

enum class ConstantExprKind {
  /// An integer constant expression (an array bound, enumerator, case value,
  /// bit-field width, or similar) or similar.
  Normal,
  /// A non-class template argument. Such a value is only used for mangling,
  /// not for code generation, so can refer to dllimported functions.
  NonClassTemplateArgument,
  /// A class template argument. Such a value is used for code generation.
  ClassTemplateArgument,
  /// An immediate invocation. The destruction of the end result of this
  /// evaluation is not part of the evaluation, but all other temporaries
  /// are destroyed.
  ImmediateInvocation,
};

/// Evaluate an expression that is required to be a constant expression. Does
/// not check the syntactic constraints for C and C++98 constant expressions.
bool EvaluateAsConstantExpr(
    EvalResult &Result, const ASTContext &Ctx,
    ConstantExprKind Kind = ConstantExprKind::Normal) const;

/// If the current Expr is a pointer, this will try to statically
/// determine the number of bytes available where the pointer is pointing.
/// Returns true if all of the above holds and we were able to figure out the
/// size, false otherwise.
///
/// \param Type - How to evaluate the size of the Expr, as defined by the
/// "type" parameter of __builtin_object_size
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,
                           unsigned Type) const;

/// If the current Expr is a pointer, this will try to statically
/// determine the strlen of the string pointed to.
/// Returns true if all of the above holds and we were able to figure out the
/// strlen, false otherwise.
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const;

/// Enumeration used to describe the kind of Null pointer constant
/// returned from \c isNullPointerConstant().
enum NullPointerConstantKind {
  /// Expression is not a Null pointer constant.
  NPCK_NotNull = 0,

  /// Expression is a Null pointer constant built from a zero integer
  /// expression that is not a simple, possibly parenthesized, zero literal.
  /// C++ Core Issue 903 will classify these expressions as "not pointers"
  /// once it is adopted.
  /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
  NPCK_ZeroExpression,

  /// Expression is a Null pointer constant built from a literal zero.
  NPCK_ZeroLiteral,

  /// Expression is a C++11 nullptr.
  NPCK_CXX11_nullptr,

  /// Expression is a GNU-style __null constant.
  NPCK_GNUNull
};

/// Enumeration used to describe how \c isNullPointerConstant()
/// should cope with value-dependent expressions.
enum NullPointerConstantValueDependence {
  /// Specifies that the expression should never be value-dependent.
  NPC_NeverValueDependent = 0,

  /// Specifies that a value-dependent expression of integral or
  /// dependent type should be considered a null pointer constant.
  NPC_ValueDependentIsNull,

  /// Specifies that a value-dependent expression should be considered
  /// to never be a null pointer constant.
  NPC_ValueDependentIsNotNull
};

/// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to
/// a Null pointer constant. The return value can further distinguish the
/// kind of NULL pointer constant that was detected.
NullPointerConstantKind isNullPointerConstant(
    ASTContext &Ctx,
    NullPointerConstantValueDependence NPC) const;

/// isOBJCGCCandidate - Return true if this expression may be used in a read/
/// write barrier.
bool isOBJCGCCandidate(ASTContext &Ctx) const;

/// Returns true if this expression is a bound member function.
bool isBoundMemberFunction(ASTContext &Ctx) const;

/// Given an expression of bound-member type, find the type
/// of the member.  Returns null if this is an *overloaded* bound
/// member expression.
static QualType findBoundMemberType(const Expr *expr);

/// Skip past any invisble AST nodes which might surround this
/// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,
/// but also injected CXXMemberExpr and CXXConstructExpr which represent
/// implicit conversions.
Expr *IgnoreUnlessSpelledInSource();
const Expr *IgnoreUnlessSpelledInSource() const {
  return const_cast<Expr *>(this)->IgnoreUnlessSpelledInSource();
}

/// Skip past any implicit casts which might surround this expression until
/// reaching a fixed point. Skips:
/// * ImplicitCastExpr
/// * FullExpr
Expr *IgnoreImpCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreImpCasts() const {
  return const_cast<Expr *>(this)->IgnoreImpCasts();
}

/// Skip past any casts which might surround this expression until reaching
/// a fixed point. Skips:
/// * CastExpr
/// * FullExpr
/// * MaterializeTemporaryExpr
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreCasts() const {
  return const_cast<Expr *>(this)->IgnoreCasts();
}

/// Skip past any implicit AST nodes which might surround this expression
/// until reaching a fixed point. Skips:
/// * What IgnoreImpCasts() skips
/// * MaterializeTemporaryExpr
/// * CXXBindTemporaryExpr
Expr *IgnoreImplicit() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreImplicit() const {
  return const_cast<Expr *>(this)->IgnoreImplicit();
}

/// Skip past any implicit AST nodes which might surround this expression
/// until reaching a fixed point. Same as IgnoreImplicit, except that it
/// also skips over implicit calls to constructors and conversion functions.
///
/// FIXME: Should IgnoreImplicit do this?
Expr *IgnoreImplicitAsWritten() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreImplicitAsWritten() const {
  return const_cast<Expr *>(this)->IgnoreImplicitAsWritten();
}

/// Skip past any parentheses which might surround this expression until
/// reaching a fixed point. Skips:
/// * ParenExpr
/// * UnaryOperator if `UO_Extension`
/// * GenericSelectionExpr if `!isResultDependent()`
/// * ChooseExpr if `!isConditionDependent()`
/// * ConstantExpr
Expr *IgnoreParens() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParens() const {
  return const_cast<Expr *>(this)->IgnoreParens();
}

/// Skip past any parentheses and implicit casts which might surround this
/// expression until reaching a fixed point.
/// FIXME: IgnoreParenImpCasts really ought to be equivalent to
/// IgnoreParens() + IgnoreImpCasts() until reaching a fixed point. However
/// this is currently not the case. Instead IgnoreParenImpCasts() skips:
/// * What IgnoreParens() skips
/// * What IgnoreImpCasts() skips
/// * MaterializeTemporaryExpr
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreParenImpCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenImpCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenImpCasts();
}

/// Skip past any parentheses and casts which might surround this expression
/// until reaching a fixed point. Skips:
/// * What IgnoreParens() skips
/// * What IgnoreCasts() skips
Expr *IgnoreParenCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenCasts();
}

/// Skip conversion operators. If this Expr is a call to a conversion
/// operator, return the argument.
Expr *IgnoreConversionOperatorSingleStep() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreConversionOperatorSingleStep() const {
  return const_cast<Expr *>(this)->IgnoreConversionOperatorSingleStep();
}

/// Skip past any parentheses and lvalue casts which might surround this
/// expression until reaching a fixed point. Skips:
/// * What IgnoreParens() skips
/// * What IgnoreCasts() skips, except that only lvalue-to-rvalue
///   casts are skipped
/// FIXME: This is intended purely as a temporary workaround for code
/// that hasn't yet been rewritten to do the right thing about those
/// casts, and may disappear along with the last internal use.
Expr *IgnoreParenLValueCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenLValueCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenLValueCasts();
}

/// Skip past any parenthese and casts which do not change the value
/// (including ptr->int casts of the same size) until reaching a fixed point.
/// Skips:
/// * What IgnoreParens() skips
/// * CastExpr which do not change the value
/// * SubstNonTypeTemplateParmExpr
Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenNoopCasts(const ASTContext &Ctx) const {
  return const_cast<Expr *>(this)->IgnoreParenNoopCasts(Ctx);
}

/// Skip past any parentheses and derived-to-base casts until reaching a
/// fixed point. Skips:
/// * What IgnoreParens() skips
/// * CastExpr which represent a derived-to-base cast (CK_DerivedToBase,
///   CK_UncheckedDerivedToBase and CK_NoOp)
Expr *IgnoreParenBaseCasts() LLVM_READONLY__attribute__((__pure__));
const Expr *IgnoreParenBaseCasts() const {
  return const_cast<Expr *>(this)->IgnoreParenBaseCasts();
}

/// Determine whether this expression is a default function argument.
///
/// Default arguments are implicitly generated in the abstract syntax tree
/// by semantic analysis for function calls, object constructions, etc. in
/// C++. Default arguments are represented by \c CXXDefaultArgExpr nodes;
/// this routine also looks through any implicit casts to determine whether
/// the expression is a default argument.
bool isDefaultArgument() const;

/// Determine whether the result of this expression is a
/// temporary object of the given class type.
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const;

/// Whether this expression is an implicit reference to 'this' in C++.
bool isImplicitCXXThis() const;

static bool hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs);

/// For an expression of class type or pointer to class type,
/// return the most derived class decl the expression is known to refer to.
///
/// If this expression is a cast, this method looks through it to find the
/// most derived decl that can be inferred from the expression.
/// This is valid because derived-to-base conversions have undefined
/// behavior if the object isn't dynamically of the derived type.
const CXXRecordDecl *getBestDynamicClassType() const;

/// Get the inner expression that determines the best dynamic class.
/// If this is a prvalue, we guarantee that it is of the most-derived type
/// for the object itself.
const Expr *getBestDynamicClassTypeExpr() const;

/// Walk outwards from an expression we want to bind a reference to and
/// find the expression whose lifetime needs to be extended. Record
/// the LHSs of comma expressions and adjustments needed along the path.
const Expr *skipRValueSubobjectAdjustments(
    SmallVectorImpl<const Expr *> &CommaLHS,
    SmallVectorImpl<SubobjectAdjustment> &Adjustments) const;
const Expr *skipRValueSubobjectAdjustments() const {
  SmallVector<const Expr *, 8> CommaLHSs;
  SmallVector<SubobjectAdjustment, 8> Adjustments;
  return skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
}

/// Checks that the two Expr's will refer to the same value as a comparison
/// operand.  The caller must ensure that the values referenced by the Expr's
/// are not modified between E1 and E2 or the result my be invalid.
static bool isSameComparisonOperand(const Expr* E1, const Expr* E2);

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstExprConstant &&
         T->getStmtClass() <= lastExprConstant;
}
984};
985// PointerLikeTypeTraits is specialized so it can be used with a forward-decl of
986// Expr. Verify that we got it right.
987static_assert(llvm::PointerLikeTypeTraits<Expr *>::NumLowBitsAvailable <=
                llvm::detail::ConstantLog2<alignof(Expr)>::value,
            "PointerLikeTypeTraits<Expr*> assumes too much alignment.");

991using ConstantExprKind = Expr::ConstantExprKind;

993//===----------------------------------------------------------------------===//
994// Wrapper Expressions.
995//===----------------------------------------------------------------------===//

997/// FullExpr - Represents a "full-expression" node.
998class FullExpr : public Expr {
999protected:
Stmt *SubExpr;

FullExpr(StmtClass SC, Expr *subexpr)
   : Expr(SC, subexpr->getType(), subexpr->getValueKind(),
          subexpr->getObjectKind()),
     SubExpr(subexpr) {
 setDependence(computeDependence(this));
}
FullExpr(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty) {}
1010public:
const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
Expr *getSubExpr() { return cast<Expr>(SubExpr); }

/// As with any mutator of the AST, be very careful when modifying an
/// existing AST to preserve its invariants.
void setSubExpr(Expr *E) { SubExpr = E; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstFullExprConstant &&
         T->getStmtClass() <= lastFullExprConstant;
}
1022};

1024/// ConstantExpr - An expression that occurs in a constant context and
1025/// optionally the result of evaluating the expression.
1026class ConstantExpr final
  : public FullExpr,
    private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
              "ConstantExpr assumes that llvm::APInt::WordType is uint64_t "
              "for tail-allocated storage");
friend TrailingObjects;
friend class ASTStmtReader;
friend class ASTStmtWriter;

1036public:
/// Describes the kind of result that can be tail-allocated.
enum ResultStorageKind { RSK_None, RSK_Int64, RSK_APValue };

1040private:
size_t numTrailingObjects(OverloadToken<APValue>) const {
  return ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue;
}
size_t numTrailingObjects(OverloadToken<uint64_t>) const {
  return ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64;
}

uint64_t &Int64Result() {
  assert(ConstantExprBits.ResultKind == ConstantExpr::RSK_Int64 &&(static_cast<void> (0))
         "invalid accessor")(static_cast<void> (0));
  return *getTrailingObjects<uint64_t>();
}
const uint64_t &Int64Result() const {
  return const_cast<ConstantExpr *>(this)->Int64Result();
}
APValue &APValueResult() {
  assert(ConstantExprBits.ResultKind == ConstantExpr::RSK_APValue &&(static_cast<void> (0))
         "invalid accessor")(static_cast<void> (0));
  return *getTrailingObjects<APValue>();
}
APValue &APValueResult() const {
  return const_cast<ConstantExpr *>(this)->APValueResult();
}

ConstantExpr(Expr *SubExpr, ResultStorageKind StorageKind,
             bool IsImmediateInvocation);
ConstantExpr(EmptyShell Empty, ResultStorageKind StorageKind);

1069public:
static ConstantExpr *Create(const ASTContext &Context, Expr *E,
                            const APValue &Result);
static ConstantExpr *Create(const ASTContext &Context, Expr *E,
                            ResultStorageKind Storage = RSK_None,
                            bool IsImmediateInvocation = false);
static ConstantExpr *CreateEmpty(const ASTContext &Context,
                                 ResultStorageKind StorageKind);

static ResultStorageKind getStorageKind(const APValue &Value);
static ResultStorageKind getStorageKind(const Type *T,
                                        const ASTContext &Context);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConstantExprClass;
}

void SetResult(APValue Value, const ASTContext &Context) {
  MoveIntoResult(Value, Context);
}
void MoveIntoResult(APValue &Value, const ASTContext &Context);

APValue::ValueKind getResultAPValueKind() const {
  return static_cast<APValue::ValueKind>(ConstantExprBits.APValueKind);
}
ResultStorageKind getResultStorageKind() const {
  return static_cast<ResultStorageKind>(ConstantExprBits.ResultKind);
}
bool isImmediateInvocation() const {
  return ConstantExprBits.IsImmediateInvocation;
}
bool hasAPValueResult() const {
  return ConstantExprBits.APValueKind != APValue::None;
}
APValue getAPValueResult() const;
APValue &getResultAsAPValue() const { return APValueResult(); }
llvm::APSInt getResultAsAPSInt() const;
// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr+1); }
const_child_range children() const {
  return const_child_range(&SubExpr, &SubExpr + 1);
}
1118};

1120//===----------------------------------------------------------------------===//
1121// Primary Expressions.
1122//===----------------------------------------------------------------------===//

1124/// OpaqueValueExpr - An expression referring to an opaque object of a
1125/// fixed type and value class.  These don't correspond to concrete
1126/// syntax; instead they're used to express operations (usually copy
1127/// operations) on values whose source is generally obvious from
1128/// context.
1129class OpaqueValueExpr : public Expr {
friend class ASTStmtReader;
Expr *SourceExpr;

1133public:
OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK,
                ExprObjectKind OK = OK_Ordinary, Expr *SourceExpr = nullptr)
    : Expr(OpaqueValueExprClass, T, VK, OK), SourceExpr(SourceExpr) {
  setIsUnique(false);
  OpaqueValueExprBits.Loc = Loc;
  setDependence(computeDependence(this));
}

/// Given an expression which invokes a copy constructor --- i.e.  a
/// CXXConstructExpr, possibly wrapped in an ExprWithCleanups ---
/// find the OpaqueValueExpr that's the source of the construction.
static const OpaqueValueExpr *findInCopyConstruct(const Expr *expr);

explicit OpaqueValueExpr(EmptyShell Empty)
  : Expr(OpaqueValueExprClass, Empty) {}

/// Retrieve the location of this expression.
SourceLocation getLocation() const { return OpaqueValueExprBits.Loc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getBeginLoc() : getLocation();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getEndLoc() : getLocation();
}
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceExpr ? SourceExpr->getExprLoc() : getLocation();
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

/// The source expression of an opaque value expression is the
/// expression which originally generated the value.  This is
/// provided as a convenience for analyses that don't wish to
/// precisely model the execution behavior of the program.
///
/// The source expression is typically set when building the
/// expression which binds the opaque value expression in the first
/// place.
Expr *getSourceExpr() const { return SourceExpr; }

void setIsUnique(bool V) {
  assert((!V || SourceExpr) &&(static_cast<void> (0))
         "unique OVEs are expected to have source expressions")(static_cast<void> (0));
  OpaqueValueExprBits.IsUnique = V;
}

bool isUnique() const { return OpaqueValueExprBits.IsUnique; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OpaqueValueExprClass;
}
1192};

1194/// A reference to a declared variable, function, enum, etc.
1195/// [C99 6.5.1p2]
1196///
1197/// This encodes all the information about how a declaration is referenced
1198/// within an expression.
1199///
1200/// There are several optional constructs attached to DeclRefExprs only when
1201/// they apply in order to conserve memory. These are laid out past the end of
1202/// the object, and flags in the DeclRefExprBitfield track whether they exist:
1203///
1204///   DeclRefExprBits.HasQualifier:
1205///       Specifies when this declaration reference expression has a C++
1206///       nested-name-specifier.
1207///   DeclRefExprBits.HasFoundDecl:
1208///       Specifies when this declaration reference expression has a record of
1209///       a NamedDecl (different from the referenced ValueDecl) which was found
1210///       during name lookup and/or overload resolution.
1211///   DeclRefExprBits.HasTemplateKWAndArgsInfo:
1212///       Specifies when this declaration reference expression has an explicit
1213///       C++ template keyword and/or template argument list.
1214///   DeclRefExprBits.RefersToEnclosingVariableOrCapture
1215///       Specifies when this declaration reference expression (validly)
1216///       refers to an enclosed local or a captured variable.
1217class DeclRefExpr final
  : public Expr,
    private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
                                  NamedDecl *, ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The declaration that we are referencing.
ValueDecl *D;

/// Provides source/type location info for the declaration name
/// embedded in D.
DeclarationNameLoc DNLoc;

size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>) const {
  return hasQualifier();
}

size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {
  return hasFoundDecl();
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

/// Test whether there is a distinct FoundDecl attached to the end of
/// this DRE.
bool hasFoundDecl() const { return DeclRefExprBits.HasFoundDecl; }

DeclRefExpr(const ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
            SourceLocation TemplateKWLoc, ValueDecl *D,
            bool RefersToEnlosingVariableOrCapture,
            const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
            const TemplateArgumentListInfo *TemplateArgs, QualType T,
            ExprValueKind VK, NonOdrUseReason NOUR);

/// Construct an empty declaration reference expression.
explicit DeclRefExpr(EmptyShell Empty) : Expr(DeclRefExprClass, Empty) {}

1259public:
DeclRefExpr(const ASTContext &Ctx, ValueDecl *D,
            bool RefersToEnclosingVariableOrCapture, QualType T,
            ExprValueKind VK, SourceLocation L,
            const DeclarationNameLoc &LocInfo = DeclarationNameLoc(),
            NonOdrUseReason NOUR = NOUR_None);

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
       QualType T, ExprValueKind VK, NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr,
       NonOdrUseReason NOUR = NOUR_None);

static DeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, ValueDecl *D,
       bool RefersToEnclosingVariableOrCapture,
       const DeclarationNameInfo &NameInfo, QualType T, ExprValueKind VK,
       NamedDecl *FoundD = nullptr,
       const TemplateArgumentListInfo *TemplateArgs = nullptr,
       NonOdrUseReason NOUR = NOUR_None);

/// Construct an empty declaration reference expression.
static DeclRefExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
                                bool HasFoundDecl,
                                bool HasTemplateKWAndArgsInfo,
                                unsigned NumTemplateArgs);

ValueDecl *getDecl() { return D; }
const ValueDecl *getDecl() const { return D; }
void setDecl(ValueDecl *NewD);

DeclarationNameInfo getNameInfo() const {
  return DeclarationNameInfo(getDecl()->getDeclName(), getLocation(), DNLoc);
}

SourceLocation getLocation() const { return DeclRefExprBits.Loc; }
void setLocation(SourceLocation L) { DeclRefExprBits.Loc = L; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

/// Determine whether this declaration reference was preceded by a
/// C++ nested-name-specifier, e.g., \c N::foo.
bool hasQualifier() const { return DeclRefExprBits.HasQualifier; }

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name, with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!hasQualifier())
    return NestedNameSpecifierLoc();
  return *getTrailingObjects<NestedNameSpecifierLoc>();
}

/// If the name was qualified, retrieves the nested-name-specifier
/// that precedes the name. Otherwise, returns NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Get the NamedDecl through which this reference occurred.
///
/// This Decl may be different from the ValueDecl actually referred to in the
/// presence of using declarations, etc. It always returns non-NULL, and may
/// simple return the ValueDecl when appropriate.

NamedDecl *getFoundDecl() {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

/// Get the NamedDecl through which this reference occurred.
/// See non-const variant.
const NamedDecl *getFoundDecl() const {
  return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() : D;
}

bool hasTemplateKWAndArgsInfo() const {
  return DeclRefExprBits.HasTemplateKWAndArgsInfo;
}

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the name in this declaration reference
/// was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this declaration reference was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;
  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Returns true if this expression refers to a function that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return DeclRefExprBits.HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a function that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  DeclRefExprBits.HadMultipleCandidates = V;
}

/// Is this expression a non-odr-use reference, and if so, why?
NonOdrUseReason isNonOdrUse() const {
  return static_cast<NonOdrUseReason>(DeclRefExprBits.NonOdrUseReason);
}

/// Does this DeclRefExpr refer to an enclosing local or a captured
/// variable?
bool refersToEnclosingVariableOrCapture() const {
  return DeclRefExprBits.RefersToEnclosingVariableOrCapture;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DeclRefExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1435};

1437/// Used by IntegerLiteral/FloatingLiteral to store the numeric without
1438/// leaking memory.
1439///
1440/// For large floats/integers, APFloat/APInt will allocate memory from the heap
1441/// to represent these numbers.  Unfortunately, when we use a BumpPtrAllocator
1442/// to allocate IntegerLiteral/FloatingLiteral nodes the memory associated with
1443/// the APFloat/APInt values will never get freed. APNumericStorage uses
1444/// ASTContext's allocator for memory allocation.
1445class APNumericStorage {
union {
  uint64_t VAL;    ///< Used to store the <= 64 bits integer value.
  uint64_t *pVal;  ///< Used to store the >64 bits integer value.
};
unsigned BitWidth;

bool hasAllocation() const { return llvm::APInt::getNumWords(BitWidth) > 1; }

APNumericStorage(const APNumericStorage &) = delete;
void operator=(const APNumericStorage &) = delete;

1457protected:
APNumericStorage() : VAL(0), BitWidth(0) { }

llvm::APInt getIntValue() const {
  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
  if (NumWords > 1)
    return llvm::APInt(BitWidth, NumWords, pVal);
  else
    return llvm::APInt(BitWidth, VAL);
}
void setIntValue(const ASTContext &C, const llvm::APInt &Val);
1468};

1470class APIntStorage : private APNumericStorage {
1471public:
llvm::APInt getValue() const { return getIntValue(); }
void setValue(const ASTContext &C, const llvm::APInt &Val) {
  setIntValue(C, Val);
}
1476};

1478class APFloatStorage : private APNumericStorage {
1479public:
llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const {
  return llvm::APFloat(Semantics, getIntValue());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  setIntValue(C, Val.bitcastToAPInt());
}
1486};

1488class IntegerLiteral : public Expr, public APIntStorage {
SourceLocation Loc;

/// Construct an empty integer literal.
explicit IntegerLiteral(EmptyShell Empty)
  : Expr(IntegerLiteralClass, Empty) { }

1495public:
// type should be IntTy, LongTy, LongLongTy, UnsignedIntTy, UnsignedLongTy,
// or UnsignedLongLongTy
IntegerLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
               SourceLocation l);

/// Returns a new integer literal with value 'V' and type 'type'.
/// \param type - either IntTy, LongTy, LongLongTy, UnsignedIntTy,
/// UnsignedLongTy, or UnsignedLongLongTy which should match the size of V
/// \param V - the value that the returned integer literal contains.
static IntegerLiteral *Create(const ASTContext &C, const llvm::APInt &V,
                              QualType type, SourceLocation l);
/// Returns a new empty integer literal.
static IntegerLiteral *Create(const ASTContext &C, EmptyShell Empty);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == IntegerLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1529};

1531class FixedPointLiteral : public Expr, public APIntStorage {
SourceLocation Loc;
unsigned Scale;

/// \brief Construct an empty fixed-point literal.
explicit FixedPointLiteral(EmptyShell Empty)
    : Expr(FixedPointLiteralClass, Empty) {}

public:
FixedPointLiteral(const ASTContext &C, const llvm::APInt &V, QualType type,
                  SourceLocation l, unsigned Scale);

// Store the int as is without any bit shifting.
static FixedPointLiteral *CreateFromRawInt(const ASTContext &C,
                                           const llvm::APInt &V,
                                           QualType type, SourceLocation l,
                                           unsigned Scale);

/// Returns an empty fixed-point literal.
static FixedPointLiteral *Create(const ASTContext &C, EmptyShell Empty);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

/// \brief Retrieve the location of the literal.
SourceLocation getLocation() const { return Loc; }

void setLocation(SourceLocation Location) { Loc = Location; }

unsigned getScale() const { return Scale; }
void setScale(unsigned S) { Scale = S; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FixedPointLiteralClass;
}

std::string getValueAsString(unsigned Radix) const;

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1576};

1578class CharacterLiteral : public Expr {
1579public:
enum CharacterKind {
  Ascii,
  Wide,
  UTF8,
  UTF16,
  UTF32
};

1588private:
unsigned Value;
SourceLocation Loc;
1591public:
// type should be IntTy
CharacterLiteral(unsigned value, CharacterKind kind, QualType type,
                 SourceLocation l)
    : Expr(CharacterLiteralClass, type, VK_PRValue, OK_Ordinary),
      Value(value), Loc(l) {
  CharacterLiteralBits.Kind = kind;
  setDependence(ExprDependence::None);
}

/// Construct an empty character literal.
CharacterLiteral(EmptyShell Empty) : Expr(CharacterLiteralClass, Empty) { }

SourceLocation getLocation() const { return Loc; }
CharacterKind getKind() const {
  return static_cast<CharacterKind>(CharacterLiteralBits.Kind);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

unsigned getValue() const { return Value; }

void setLocation(SourceLocation Location) { Loc = Location; }
void setKind(CharacterKind kind) { CharacterLiteralBits.Kind = kind; }
void setValue(unsigned Val) { Value = Val; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CharacterLiteralClass;
}

static void print(unsigned val, CharacterKind Kind, raw_ostream &OS);

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1631};

1633class FloatingLiteral : public Expr, private APFloatStorage {
SourceLocation Loc;

FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, bool isexact,
                QualType Type, SourceLocation L);

/// Construct an empty floating-point literal.
explicit FloatingLiteral(const ASTContext &C, EmptyShell Empty);

1642public:
static FloatingLiteral *Create(const ASTContext &C, const llvm::APFloat &V,
                               bool isexact, QualType Type, SourceLocation L);
static FloatingLiteral *Create(const ASTContext &C, EmptyShell Empty);

llvm::APFloat getValue() const {
  return APFloatStorage::getValue(getSemantics());
}
void setValue(const ASTContext &C, const llvm::APFloat &Val) {
  assert(&getSemantics() == &Val.getSemantics() && "Inconsistent semantics")(static_cast<void> (0));
  APFloatStorage::setValue(C, Val);
}

/// Get a raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
llvm::APFloatBase::Semantics getRawSemantics() const {
  return static_cast<llvm::APFloatBase::Semantics>(
      FloatingLiteralBits.Semantics);
}

/// Set the raw enumeration value representing the floating-point semantics of
/// this literal (32-bit IEEE, x87, ...), suitable for serialisation.
void setRawSemantics(llvm::APFloatBase::Semantics Sem) {
  FloatingLiteralBits.Semantics = Sem;
}

/// Return the APFloat semantics this literal uses.
const llvm::fltSemantics &getSemantics() const {
  return llvm::APFloatBase::EnumToSemantics(
      static_cast<llvm::APFloatBase::Semantics>(
          FloatingLiteralBits.Semantics));
}

/// Set the APFloat semantics this literal uses.
void setSemantics(const llvm::fltSemantics &Sem) {
  FloatingLiteralBits.Semantics = llvm::APFloatBase::SemanticsToEnum(Sem);
}

bool isExact() const { return FloatingLiteralBits.IsExact; }
void setExact(bool E) { FloatingLiteralBits.IsExact = E; }

/// getValueAsApproximateDouble - This returns the value as an inaccurate
/// double.  Note that this may cause loss of precision, but is useful for
/// debugging dumps, etc.
double getValueAsApproximateDouble() const;

SourceLocation getLocation() const { return Loc; }
void setLocation(SourceLocation L) { Loc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == FloatingLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1705};

1707/// ImaginaryLiteral - We support imaginary integer and floating point literals,
1708/// like "1.0i".  We represent these as a wrapper around FloatingLiteral and
1709/// IntegerLiteral classes.  Instances of this class always have a Complex type
1710/// whose element type matches the subexpression.
1711///
1712class ImaginaryLiteral : public Expr {
Stmt *Val;
1714public:
ImaginaryLiteral(Expr *val, QualType Ty)
    : Expr(ImaginaryLiteralClass, Ty, VK_PRValue, OK_Ordinary), Val(val) {
  setDependence(ExprDependence::None);
}

/// Build an empty imaginary literal.
explicit ImaginaryLiteral(EmptyShell Empty)
  : Expr(ImaginaryLiteralClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return Val->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Val->getEndLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImaginaryLiteralClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
1742};

1744/// StringLiteral - This represents a string literal expression, e.g. "foo"
1745/// or L"bar" (wide strings). The actual string data can be obtained with
1746/// getBytes() and is NOT null-terminated. The length of the string data is
1747/// determined by calling getByteLength().
1748///
1749/// The C type for a string is always a ConstantArrayType. In C++, the char
1750/// type is const qualified, in C it is not.
1751///
1752/// Note that strings in C can be formed by concatenation of multiple string
1753/// literal pptokens in translation phase #6. This keeps track of the locations
1754/// of each of these pieces.
1755///
1756/// Strings in C can also be truncated and extended by assigning into arrays,
1757/// e.g. with constructs like:
1758///   char X[2] = "foobar";
1759/// In this case, getByteLength() will return 6, but the string literal will
1760/// have type "char[2]".
1761class StringLiteral final
  : public Expr,
    private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation,
                                  char> {
friend class ASTStmtReader;
friend TrailingObjects;

/// StringLiteral is followed by several trailing objects. They are in order:
///
/// * A single unsigned storing the length in characters of this string. The
///   length in bytes is this length times the width of a single character.
///   Always present and stored as a trailing objects because storing it in
///   StringLiteral would increase the size of StringLiteral by sizeof(void *)
///   due to alignment requirements. If you add some data to StringLiteral,
///   consider moving it inside StringLiteral.
///
/// * An array of getNumConcatenated() SourceLocation, one for each of the
///   token this string is made of.
///
/// * An array of getByteLength() char used to store the string data.

1782public:
enum StringKind { Ascii, Wide, UTF8, UTF16, UTF32 };

1785private:
unsigned numTrailingObjects(OverloadToken<unsigned>) const { return 1; }
unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
  return getNumConcatenated();
}

unsigned numTrailingObjects(OverloadToken<char>) const {
  return getByteLength();
}

char *getStrDataAsChar() { return getTrailingObjects<char>(); }
const char *getStrDataAsChar() const { return getTrailingObjects<char>(); }

const uint16_t *getStrDataAsUInt16() const {
  return reinterpret_cast<const uint16_t *>(getTrailingObjects<char>());
}

const uint32_t *getStrDataAsUInt32() const {
  return reinterpret_cast<const uint32_t *>(getTrailingObjects<char>());
}

/// Build a string literal.
StringLiteral(const ASTContext &Ctx, StringRef Str, StringKind Kind,
              bool Pascal, QualType Ty, const SourceLocation *Loc,
              unsigned NumConcatenated);

/// Build an empty string literal.
StringLiteral(EmptyShell Empty, unsigned NumConcatenated, unsigned Length,
              unsigned CharByteWidth);

/// Map a target and string kind to the appropriate character width.
static unsigned mapCharByteWidth(TargetInfo const &Target, StringKind SK);

/// Set one of the string literal token.
void setStrTokenLoc(unsigned TokNum, SourceLocation L) {
  assert(TokNum < getNumConcatenated() && "Invalid tok number")(static_cast<void> (0));
  getTrailingObjects<SourceLocation>()[TokNum] = L;
}

1824public:
/// This is the "fully general" constructor that allows representation of
/// strings formed from multiple concatenated tokens.
static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             const SourceLocation *Loc,
                             unsigned NumConcatenated);

/// Simple constructor for string literals made from one token.
static StringLiteral *Create(const ASTContext &Ctx, StringRef Str,
                             StringKind Kind, bool Pascal, QualType Ty,
                             SourceLocation Loc) {
  return Create(Ctx, Str, Kind, Pascal, Ty, &Loc, 1);
}

/// Construct an empty string literal.
static StringLiteral *CreateEmpty(const ASTContext &Ctx,
                                  unsigned NumConcatenated, unsigned Length,
                                  unsigned CharByteWidth);

StringRef getString() const {
  assert(getCharByteWidth() == 1 &&(static_cast<void> (0))
         "This function is used in places that assume strings use char")(static_cast<void> (0));
  return StringRef(getStrDataAsChar(), getByteLength());
}

/// Allow access to clients that need the byte representation, such as
/// ASTWriterStmt::VisitStringLiteral().
StringRef getBytes() const {
  // FIXME: StringRef may not be the right type to use as a result for this.
  return StringRef(getStrDataAsChar(), getByteLength());
}

void outputString(raw_ostream &OS) const;

uint32_t getCodeUnit(size_t i) const {
  assert(i < getLength() && "out of bounds access")(static_cast<void> (0));
  switch (getCharByteWidth()) {
  case 1:
    return static_cast<unsigned char>(getStrDataAsChar()[i]);
  case 2:
    return getStrDataAsUInt16()[i];
  case 4:
    return getStrDataAsUInt32()[i];
  }
  llvm_unreachable("Unsupported character width!")__builtin_unreachable();
}

unsigned getByteLength() const { return getCharByteWidth() * getLength(); }
unsigned getLength() const { return *getTrailingObjects<unsigned>(); }
unsigned getCharByteWidth() const { return StringLiteralBits.CharByteWidth; }

StringKind getKind() const {
  return static_cast<StringKind>(StringLiteralBits.Kind);
}

bool isAscii() const { return getKind() == Ascii; }
bool isWide() const { return getKind() == Wide; }
bool isUTF8() const { return getKind() == UTF8; }
bool isUTF16() const { return getKind() == UTF16; }
bool isUTF32() const { return getKind() == UTF32; }
bool isPascal() const { return StringLiteralBits.IsPascal; }

bool containsNonAscii() const {
  for (auto c : getString())
    if (!isASCII(c))
      return true;
  return false;
}

bool containsNonAsciiOrNull() const {
  for (auto c : getString())
    if (!isASCII(c) || !c)
      return true;
  return false;
}

/// getNumConcatenated - Get the number of string literal tokens that were
/// concatenated in translation phase #6 to form this string literal.
unsigned getNumConcatenated() const {
  return StringLiteralBits.NumConcatenated;
}

/// Get one of the string literal token.
SourceLocation getStrTokenLoc(unsigned TokNum) const {
  assert(TokNum < getNumConcatenated() && "Invalid tok number")(static_cast<void> (0));
  return getTrailingObjects<SourceLocation>()[TokNum];
}

/// getLocationOfByte - Return a source location that points to the specified
/// byte of this string literal.
///
/// Strings are amazingly complex.  They can be formed from multiple tokens
/// and can have escape sequences in them in addition to the usual trigraph
/// and escaped newline business.  This routine handles this complexity.
///
SourceLocation
getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
                  const LangOptions &Features, const TargetInfo &Target,
                  unsigned *StartToken = nullptr,
                  unsigned *StartTokenByteOffset = nullptr) const;

typedef const SourceLocation *tokloc_iterator;

tokloc_iterator tokloc_begin() const {
  return getTrailingObjects<SourceLocation>();
}

tokloc_iterator tokloc_end() const {
  return getTrailingObjects<SourceLocation>() + getNumConcatenated();
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return *tokloc_begin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return *(tokloc_end() - 1); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StringLiteralClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1950};

1952/// [C99 6.4.2.2] - A predefined identifier such as __func__.
1953class PredefinedExpr final
  : public Expr,
    private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
friend class ASTStmtReader;
friend TrailingObjects;

// PredefinedExpr is optionally followed by a single trailing
// "Stmt *" for the predefined identifier. It is present if and only if
// hasFunctionName() is true and is always a "StringLiteral *".

1963public:
enum IdentKind {
  Func,
  Function,
  LFunction, // Same as Function, but as wide string.
  FuncDName,
  FuncSig,
  LFuncSig, // Same as FuncSig, but as as wide string
  PrettyFunction,
  /// The same as PrettyFunction, except that the
  /// 'virtual' keyword is omitted for virtual member functions.
  PrettyFunctionNoVirtual
};

1977private:
PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
               StringLiteral *SL);

explicit PredefinedExpr(EmptyShell Empty, bool HasFunctionName);

/// True if this PredefinedExpr has storage for a function name.
bool hasFunctionName() const { return PredefinedExprBits.HasFunctionName; }

void setFunctionName(StringLiteral *SL) {
  assert(hasFunctionName() &&(static_cast<void> (0))
         "This PredefinedExpr has no storage for a function name!")(static_cast<void> (0));
  *getTrailingObjects<Stmt *>() = SL;
}

1992public:
/// Create a PredefinedExpr.
static PredefinedExpr *Create(const ASTContext &Ctx, SourceLocation L,
                              QualType FNTy, IdentKind IK, StringLiteral *SL);

/// Create an empty PredefinedExpr.
static PredefinedExpr *CreateEmpty(const ASTContext &Ctx,
                                   bool HasFunctionName);

IdentKind getIdentKind() const {
  return static_cast<IdentKind>(PredefinedExprBits.Kind);
}

SourceLocation getLocation() const { return PredefinedExprBits.Loc; }
void setLocation(SourceLocation L) { PredefinedExprBits.Loc = L; }

StringLiteral *getFunctionName() {
  return hasFunctionName()
             ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
             : nullptr;
}

const StringLiteral *getFunctionName() const {
  return hasFunctionName()
             ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
             : nullptr;
}

static StringRef getIdentKindName(IdentKind IK);
StringRef getIdentKindName() const {
  return getIdentKindName(getIdentKind());
}

static std::string ComputeName(IdentKind IK, const Decl *CurrentDecl);

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return getLocation(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PredefinedExprClass;
}

// Iterators
child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() + hasFunctionName());
}

const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() + hasFunctionName());
}
2044};

2046// This represents a use of the __builtin_sycl_unique_stable_name, which takes a
2047// type-id, and at CodeGen time emits a unique string representation of the
2048// type in a way that permits us to properly encode information about the SYCL
2049// kernels.
2050class SYCLUniqueStableNameExpr final : public Expr {
friend class ASTStmtReader;
SourceLocation OpLoc, LParen, RParen;
TypeSourceInfo *TypeInfo;

SYCLUniqueStableNameExpr(EmptyShell Empty, QualType ResultTy);
SYCLUniqueStableNameExpr(SourceLocation OpLoc, SourceLocation LParen,
                         SourceLocation RParen, QualType ResultTy,
                         TypeSourceInfo *TSI);

void setTypeSourceInfo(TypeSourceInfo *Ty) { TypeInfo = Ty; }

void setLocation(SourceLocation L) { OpLoc = L; }
void setLParenLocation(SourceLocation L) { LParen = L; }
void setRParenLocation(SourceLocation L) { RParen = L; }

2066public:
TypeSourceInfo *getTypeSourceInfo() { return TypeInfo; }

const TypeSourceInfo *getTypeSourceInfo() const { return TypeInfo; }

static SYCLUniqueStableNameExpr *
Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen,
       SourceLocation RParen, TypeSourceInfo *TSI);

static SYCLUniqueStableNameExpr *CreateEmpty(const ASTContext &Ctx);

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return RParen; }
SourceLocation getLocation() const { return OpLoc; }
SourceLocation getLParenLocation() const { return LParen; }
SourceLocation getRParenLocation() const { return RParen; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == SYCLUniqueStableNameExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

// Convenience function to generate the name of the currently stored type.
std::string ComputeName(ASTContext &Context) const;

// Get the generated name of the type.  Note that this only works after all
// kernels have been instantiated.
static std::string ComputeName(ASTContext &Context, QualType Ty);
2102};

2104/// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
2105/// AST node is only formed if full location information is requested.
2106class ParenExpr : public Expr {
SourceLocation L, R;
Stmt *Val;
2109public:
ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
    : Expr(ParenExprClass, val->getType(), val->getValueKind(),
           val->getObjectKind()),
      L(l), R(r), Val(val) {
  setDependence(computeDependence(this));
}

/// Construct an empty parenthesized expression.
explicit ParenExpr(EmptyShell Empty)
  : Expr(ParenExprClass, Empty) { }

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return L; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return R; }

/// Get the location of the left parentheses '('.
SourceLocation getLParen() const { return L; }
void setLParen(SourceLocation Loc) { L = Loc; }

/// Get the location of the right parentheses ')'.
SourceLocation getRParen() const { return R; }
void setRParen(SourceLocation Loc) { R = Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
2145};

2147/// UnaryOperator - This represents the unary-expression's (except sizeof and
2148/// alignof), the postinc/postdec operators from postfix-expression, and various
2149/// extensions.
2150///
2151/// Notes on various nodes:
2152///
2153/// Real/Imag - These return the real/imag part of a complex operand.  If
2154///   applied to a non-complex value, the former returns its operand and the
2155///   later returns zero in the type of the operand.
2156///
2157class UnaryOperator final
  : public Expr,
    private llvm::TrailingObjects<UnaryOperator, FPOptionsOverride> {
Stmt *Val;

size_t numTrailingObjects(OverloadToken<FPOptionsOverride>) const {
  return UnaryOperatorBits.HasFPFeatures ? 1 : 0;
}

FPOptionsOverride &getTrailingFPFeatures() {
  assert(UnaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
  return *getTrailingObjects<FPOptionsOverride>();
}

const FPOptionsOverride &getTrailingFPFeatures() const {
  assert(UnaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
  return *getTrailingObjects<FPOptionsOverride>();
}

2176public:
typedef UnaryOperatorKind Opcode;

2179protected:
UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc, QualType type,
              ExprValueKind VK, ExprObjectKind OK, SourceLocation l,
              bool CanOverflow, FPOptionsOverride FPFeatures);

/// Build an empty unary operator.
explicit UnaryOperator(bool HasFPFeatures, EmptyShell Empty)
    : Expr(UnaryOperatorClass, Empty) {
  UnaryOperatorBits.Opc = UO_AddrOf;
  UnaryOperatorBits.HasFPFeatures = HasFPFeatures;
}

2191public:
static UnaryOperator *CreateEmpty(const ASTContext &C, bool hasFPFeatures);

static UnaryOperator *Create(const ASTContext &C, Expr *input, Opcode opc,
                             QualType type, ExprValueKind VK,
                             ExprObjectKind OK, SourceLocation l,
                             bool CanOverflow, FPOptionsOverride FPFeatures);

Opcode getOpcode() const {
  return static_cast<Opcode>(UnaryOperatorBits.Opc);
}
void setOpcode(Opcode Opc) { UnaryOperatorBits.Opc = Opc; }

Expr *getSubExpr() const { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return UnaryOperatorBits.Loc; }
void setOperatorLoc(SourceLocation L) { UnaryOperatorBits.Loc = L; }

/// Returns true if the unary operator can cause an overflow. For instance,
///   signed int i = INT_MAX; i++;
///   signed char c = CHAR_MAX; c++;
/// Due to integer promotions, c++ is promoted to an int before the postfix
/// increment, and the result is an int that cannot overflow. However, i++
/// can overflow.
bool canOverflow() const { return UnaryOperatorBits.CanOverflow; }
void setCanOverflow(bool C) { UnaryOperatorBits.CanOverflow = C; }

// Get the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
bool isFPContractableWithinStatement(const LangOptions &LO) const {
  return getFPFeaturesInEffect(LO).allowFPContractWithinStatement();
}

// Get the FENV_ACCESS status of this operator. Only meaningful for
// operations on floating point types.
bool isFEnvAccessOn(const LangOptions &LO) const {
  return getFPFeaturesInEffect(LO).getAllowFEnvAccess();
}

/// isPostfix - Return true if this is a postfix operation, like x++.
static bool isPostfix(Opcode Op) {
  return Op == UO_PostInc || Op == UO_PostDec;
}

/// isPrefix - Return true if this is a prefix operation, like --x.
static bool isPrefix(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PreDec;
}

bool isPrefix() const { return isPrefix(getOpcode()); }
bool isPostfix() const { return isPostfix(getOpcode()); }

static bool isIncrementOp(Opcode Op) {
  return Op == UO_PreInc || Op == UO_PostInc;
}
bool isIncrementOp() const {
  return isIncrementOp(getOpcode());
}

static bool isDecrementOp(Opcode Op) {
  return Op == UO_PreDec || Op == UO_PostDec;
}
bool isDecrementOp() const {
  return isDecrementOp(getOpcode());
}

static bool isIncrementDecrementOp(Opcode Op) { return Op <= UO_PreDec; }
bool isIncrementDecrementOp() const {
  return isIncrementDecrementOp(getOpcode());
}

static bool isArithmeticOp(Opcode Op) {
  return Op >= UO_Plus && Op <= UO_LNot;
}
bool isArithmeticOp() const { return isArithmeticOp(getOpcode()); }

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "sizeof" or "[pre]++"
static StringRef getOpcodeStr(Opcode Op);

/// Retrieve the unary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix);

/// Retrieve the overloaded operator kind that corresponds to
/// the given unary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? Val->getBeginLoc() : getOperatorLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return isPostfix() ? getOperatorLoc() : Val->getEndLoc();
}
SourceLocation getExprLoc() const { return getOperatorLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryOperatorClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}

/// Is FPFeatures in Trailing Storage?
bool hasStoredFPFeatures() const { return UnaryOperatorBits.HasFPFeatures; }

/// Get FPFeatures from trailing storage.
FPOptionsOverride getStoredFPFeatures() const {
  return getTrailingFPFeatures();
}

2307protected:
/// Set FPFeatures in trailing storage, used only by Serialization
void setStoredFPFeatures(FPOptionsOverride F) { getTrailingFPFeatures() = F; }

2311public:
// Get the FP features status of this operator. Only meaningful for
// operations on floating point types.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const {
  if (UnaryOperatorBits.HasFPFeatures)
    return getStoredFPFeatures().applyOverrides(LO);
  return FPOptions::defaultWithoutTrailingStorage(LO);
}
FPOptionsOverride getFPOptionsOverride() const {
  if (UnaryOperatorBits.HasFPFeatures)
    return getStoredFPFeatures();
  return FPOptionsOverride();
}

friend TrailingObjects;
friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
2329};

2331/// Helper class for OffsetOfExpr.

2333// __builtin_offsetof(type, identifier(.identifier|[expr])*)
2334class OffsetOfNode {
2335public:
/// The kind of offsetof node we have.
enum Kind {
  /// An index into an array.
  Array = 0x00,
  /// A field.
  Field = 0x01,
  /// A field in a dependent type, known only by its name.
  Identifier = 0x02,
  /// An implicit indirection through a C++ base class, when the
  /// field found is in a base class.
  Base = 0x03
};

2349private:
enum { MaskBits = 2, Mask = 0x03 };

/// The source range that covers this part of the designator.
SourceRange Range;

/// The data describing the designator, which comes in three
/// different forms, depending on the lower two bits.
///   - An unsigned index into the array of Expr*'s stored after this node
///     in memory, for [constant-expression] designators.
///   - A FieldDecl*, for references to a known field.
///   - An IdentifierInfo*, for references to a field with a given name
///     when the class type is dependent.
///   - A CXXBaseSpecifier*, for references that look at a field in a
///     base class.
uintptr_t Data;

2366public:
/// Create an offsetof node that refers to an array element.
OffsetOfNode(SourceLocation LBracketLoc, unsigned Index,
             SourceLocation RBracketLoc)
    : Range(LBracketLoc, RBracketLoc), Data((Index << 2) | Array) {}

/// Create an offsetof node that refers to a field.
OffsetOfNode(SourceLocation DotLoc, FieldDecl *Field, SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Field) | OffsetOfNode::Field) {}

/// Create an offsetof node that refers to an identifier.
OffsetOfNode(SourceLocation DotLoc, IdentifierInfo *Name,
             SourceLocation NameLoc)
    : Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
      Data(reinterpret_cast<uintptr_t>(Name) | Identifier) {}

/// Create an offsetof node that refers into a C++ base class.
explicit OffsetOfNode(const CXXBaseSpecifier *Base)
    : Range(), Data(reinterpret_cast<uintptr_t>(Base) | OffsetOfNode::Base) {}

/// Determine what kind of offsetof node this is.
Kind getKind() const { return static_cast<Kind>(Data & Mask); }

/// For an array element node, returns the index into the array
/// of expressions.
unsigned getArrayExprIndex() const {
  assert(getKind() == Array)(static_cast<void> (0));
  return Data >> 2;
}

/// For a field offsetof node, returns the field.
FieldDecl *getField() const {
  assert(getKind() == Field)(static_cast<void> (0));
  return reinterpret_cast<FieldDecl *>(Data & ~(uintptr_t)Mask);
}

/// For a field or identifier offsetof node, returns the name of
/// the field.
IdentifierInfo *getFieldName() const;

/// For a base class node, returns the base specifier.
CXXBaseSpecifier *getBase() const {
  assert(getKind() == Base)(static_cast<void> (0));
  return reinterpret_cast<CXXBaseSpecifier *>(Data & ~(uintptr_t)Mask);
}

/// Retrieve the source range that covers this offsetof node.
///
/// For an array element node, the source range contains the locations of
/// the square brackets. For a field or identifier node, the source range
/// contains the location of the period (if there is one) and the
/// identifier.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
2422};

2424/// OffsetOfExpr - [C99 7.17] - This represents an expression of the form
2425/// offsetof(record-type, member-designator). For example, given:
2426/// @code
2427/// struct S {
2428///   float f;
2429///   double d;
2430/// };
2431/// struct T {
2432///   int i;
2433///   struct S s[10];
2434/// };
2435/// @endcode
2436/// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).

2438class OffsetOfExpr final
  : public Expr,
    private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
SourceLocation OperatorLoc, RParenLoc;
// Base type;
TypeSourceInfo *TSInfo;
// Number of sub-components (i.e. instances of OffsetOfNode).
unsigned NumComps;
// Number of sub-expressions (i.e. array subscript expressions).
unsigned NumExprs;

size_t numTrailingObjects(OverloadToken<OffsetOfNode>) const {
  return NumComps;
}

OffsetOfExpr(const ASTContext &C, QualType type,
             SourceLocation OperatorLoc, TypeSourceInfo *tsi,
             ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
             SourceLocation RParenLoc);

explicit OffsetOfExpr(unsigned numComps, unsigned numExprs)
  : Expr(OffsetOfExprClass, EmptyShell()),
    TSInfo(nullptr), NumComps(numComps), NumExprs(numExprs) {}

2462public:

static OffsetOfExpr *Create(const ASTContext &C, QualType type,
                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                            ArrayRef<OffsetOfNode> comps,
                            ArrayRef<Expr*> exprs, SourceLocation RParenLoc);

static OffsetOfExpr *CreateEmpty(const ASTContext &C,
                                 unsigned NumComps, unsigned NumExprs);

/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }
void setOperatorLoc(SourceLocation L) { OperatorLoc = L; }

/// Return the location of the right parentheses.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation R) { RParenLoc = R; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TSInfo;
}
void setTypeSourceInfo(TypeSourceInfo *tsi) {
  TSInfo = tsi;
}

const OffsetOfNode &getComponent(unsigned Idx) const {
  assert(Idx < NumComps && "Subscript out of range")(static_cast<void> (0));
  return getTrailingObjects<OffsetOfNode>()[Idx];
}

void setComponent(unsigned Idx, OffsetOfNode ON) {
  assert(Idx < NumComps && "Subscript out of range")(static_cast<void> (0));
  getTrailingObjects<OffsetOfNode>()[Idx] = ON;
}

unsigned getNumComponents() const {
  return NumComps;
}

Expr* getIndexExpr(unsigned Idx) {
  assert(Idx < NumExprs && "Subscript out of range")(static_cast<void> (0));
  return getTrailingObjects<Expr *>()[Idx];
}

const Expr *getIndexExpr(unsigned Idx) const {
  assert(Idx < NumExprs && "Subscript out of range")(static_cast<void> (0));
  return getTrailingObjects<Expr *>()[Idx];
}

void setIndexExpr(unsigned Idx, Expr* E) {
  assert(Idx < NumComps && "Subscript out of range")(static_cast<void> (0));
  getTrailingObjects<Expr *>()[Idx] = E;
}

unsigned getNumExpressions() const {
  return NumExprs;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return OperatorLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == OffsetOfExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
  return child_range(begin, begin + NumExprs);
}
const_child_range children() const {
  Stmt *const *begin =
      reinterpret_cast<Stmt *const *>(getTrailingObjects<Expr *>());
  return const_child_range(begin, begin + NumExprs);
}
friend TrailingObjects;
2538};

2540/// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)
2541/// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and
2542/// vec_step (OpenCL 1.1 6.11.12).
2543class UnaryExprOrTypeTraitExpr : public Expr {
union {
  TypeSourceInfo *Ty;
  Stmt *Ex;
} Argument;
SourceLocation OpLoc, RParenLoc;

2550public:
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp)
    : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_PRValue,
           OK_Ordinary),
      OpLoc(op), RParenLoc(rp) {
  assert(ExprKind <= UETT_Last && "invalid enum value!")(static_cast<void> (0));
  UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
  assert(static_cast<unsigned>(ExprKind) ==(static_cast<void> (0))
             UnaryExprOrTypeTraitExprBits.Kind &&(static_cast<void> (0))
         "UnaryExprOrTypeTraitExprBits.Kind overflow!")(static_cast<void> (0));
  UnaryExprOrTypeTraitExprBits.IsType = true;
  Argument.Ty = TInfo;
  setDependence(computeDependence(this));
}

UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, Expr *E,
                         QualType resultType, SourceLocation op,
                         SourceLocation rp);

/// Construct an empty sizeof/alignof expression.
explicit UnaryExprOrTypeTraitExpr(EmptyShell Empty)
  : Expr(UnaryExprOrTypeTraitExprClass, Empty) { }

UnaryExprOrTypeTrait getKind() const {
  return static_cast<UnaryExprOrTypeTrait>(UnaryExprOrTypeTraitExprBits.Kind);
}
void setKind(UnaryExprOrTypeTrait K) {
  assert(K <= UETT_Last && "invalid enum value!")(static_cast<void> (0));
  UnaryExprOrTypeTraitExprBits.Kind = K;
  assert(static_cast<unsigned>(K) == UnaryExprOrTypeTraitExprBits.Kind &&(static_cast<void> (0))
         "UnaryExprOrTypeTraitExprBits.Kind overflow!")(static_cast<void> (0));
}

bool isArgumentType() const { return UnaryExprOrTypeTraitExprBits.IsType; }
QualType getArgumentType() const {
  return getArgumentTypeInfo()->getType();
}
TypeSourceInfo *getArgumentTypeInfo() const {
  assert(isArgumentType() && "calling getArgumentType() when arg is expr")(static_cast<void> (0));
  return Argument.Ty;
}
Expr *getArgumentExpr() {
  assert(!isArgumentType() && "calling getArgumentExpr() when arg is type")(static_cast<void> (0));
  return static_cast<Expr*>(Argument.Ex);
}
const Expr *getArgumentExpr() const {
  return const_cast<UnaryExprOrTypeTraitExpr*>(this)->getArgumentExpr();
}

void setArgument(Expr *E) {
  Argument.Ex = E;
  UnaryExprOrTypeTraitExprBits.IsType = false;
}
void setArgument(TypeSourceInfo *TInfo) {
  Argument.Ty = TInfo;
  UnaryExprOrTypeTraitExprBits.IsType = true;
}

/// Gets the argument type, or the type of the argument expression, whichever
/// is appropriate.
QualType getTypeOfArgument() const {
  return isArgumentType() ? getArgumentType() : getArgumentExpr()->getType();
}

SourceLocation getOperatorLoc() const { return OpLoc; }
void setOperatorLoc(SourceLocation L) { OpLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return OpLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
}

// Iterators
child_range children();
const_child_range children() const;
2632};

2634//===----------------------------------------------------------------------===//
2635// Postfix Operators.
2636//===----------------------------------------------------------------------===//

2638/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
2639class ArraySubscriptExpr : public Expr {
enum { LHS, RHS, END_EXPR };
Stmt *SubExprs[END_EXPR];

bool lhsIsBase() const { return getRHS()->getType()->isIntegerType(); }

2645public:
ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK,
                   ExprObjectKind OK, SourceLocation rbracketloc)
    : Expr(ArraySubscriptExprClass, t, VK, OK) {
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  ArrayOrMatrixSubscriptExprBits.RBracketLoc = rbracketloc;
  setDependence(computeDependence(this));
}

/// Create an empty array subscript expression.
explicit ArraySubscriptExpr(EmptyShell Shell)
  : Expr(ArraySubscriptExprClass, Shell) { }

/// An array access can be written A[4] or 4[A] (both are equivalent).
/// - getBase() and getIdx() always present the normalized view: A[4].
///    In this case getBase() returns "A" and getIdx() returns "4".
/// - getLHS() and getRHS() present the syntactic view. e.g. for
///    4[A] getLHS() returns "4".
/// Note: Because vector element access is also written A[4] we must
/// predicate the format conversion in getBase and getIdx only on the
/// the type of the RHS, as it is possible for the LHS to be a vector of
/// integer type
Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }

Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

Expr *getBase() { return lhsIsBase() ? getLHS() : getRHS(); }
const Expr *getBase() const { return lhsIsBase() ? getLHS() : getRHS(); }

Expr *getIdx() { return lhsIsBase() ? getRHS() : getLHS(); }
const Expr *getIdx() const { return lhsIsBase() ? getRHS() : getLHS(); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getBeginLoc();
}
SourceLocation getEndLoc() const { return getRBracketLoc(); }

SourceLocation getRBracketLoc() const {
  return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
}
void setRBracketLoc(SourceLocation L) {
  ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
}

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getExprLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ArraySubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
2709};

2711/// MatrixSubscriptExpr - Matrix subscript expression for the MatrixType
2712/// extension.
2713/// MatrixSubscriptExpr can be either incomplete (only Base and RowIdx are set
2714/// so far, the type is IncompleteMatrixIdx) or complete (Base, RowIdx and
2715/// ColumnIdx refer to valid expressions). Incomplete matrix expressions only
2716/// exist during the initial construction of the AST.
2717class MatrixSubscriptExpr : public Expr {
enum { BASE, ROW_IDX, COLUMN_IDX, END_EXPR };
Stmt *SubExprs[END_EXPR];

2721public:
MatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, QualType T,
                    SourceLocation RBracketLoc)
    : Expr(MatrixSubscriptExprClass, T, Base->getValueKind(),
           OK_MatrixComponent) {
  SubExprs[BASE] = Base;
  SubExprs[ROW_IDX] = RowIdx;
  SubExprs[COLUMN_IDX] = ColumnIdx;
  ArrayOrMatrixSubscriptExprBits.RBracketLoc = RBracketLoc;
  setDependence(computeDependence(this));
}

/// Create an empty matrix subscript expression.
explicit MatrixSubscriptExpr(EmptyShell Shell)
    : Expr(MatrixSubscriptExprClass, Shell) {}

bool isIncomplete() const {
  bool IsIncomplete = hasPlaceholderType(BuiltinType::IncompleteMatrixIdx);
  assert((SubExprs[COLUMN_IDX] || IsIncomplete) &&(static_cast<void> (0))
         "expressions without column index must be marked as incomplete")(static_cast<void> (0));
  return IsIncomplete;
}
Expr *getBase() { return cast<Expr>(SubExprs[BASE]); }
const Expr *getBase() const { return cast<Expr>(SubExprs[BASE]); }
void setBase(Expr *E) { SubExprs[BASE] = E; }

Expr *getRowIdx() { return cast<Expr>(SubExprs[ROW_IDX]); }
const Expr *getRowIdx() const { return cast<Expr>(SubExprs[ROW_IDX]); }
void setRowIdx(Expr *E) { SubExprs[ROW_IDX] = E; }

Expr *getColumnIdx() { return cast_or_null<Expr>(SubExprs[COLUMN_IDX]); }
const Expr *getColumnIdx() const {
  assert(!isIncomplete() &&(static_cast<void> (0))
         "cannot get the column index of an incomplete expression")(static_cast<void> (0));
  return cast<Expr>(SubExprs[COLUMN_IDX]);
}
void setColumnIdx(Expr *E) { SubExprs[COLUMN_IDX] = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getBeginLoc();
}

SourceLocation getEndLoc() const { return getRBracketLoc(); }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getExprLoc();
}

SourceLocation getRBracketLoc() const {
  return ArrayOrMatrixSubscriptExprBits.RBracketLoc;
}
void setRBracketLoc(SourceLocation L) {
  ArrayOrMatrixSubscriptExprBits.RBracketLoc = L;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MatrixSubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
2787};

2789/// CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
2790/// CallExpr itself represents a normal function call, e.g., "f(x, 2)",
2791/// while its subclasses may represent alternative syntax that (semantically)
2792/// results in a function call. For example, CXXOperatorCallExpr is
2793/// a subclass for overloaded operator calls that use operator syntax, e.g.,
2794/// "str1 + str2" to resolve to a function call.
2795class CallExpr : public Expr {
enum { FN = 0, PREARGS_START = 1 };

/// The number of arguments in the call expression.
unsigned NumArgs;

/// The location of the right parenthese. This has a different meaning for
/// the derived classes of CallExpr.
SourceLocation RParenLoc;

// CallExpr store some data in trailing objects. However since CallExpr
// is used a base of other expression classes we cannot use
// llvm::TrailingObjects. Instead we manually perform the pointer arithmetic
// and casts.
//
// The trailing objects are in order:
//
// * A single "Stmt *" for the callee expression.
//
// * An array of getNumPreArgs() "Stmt *" for the pre-argument expressions.
//
// * An array of getNumArgs() "Stmt *" for the argument expressions.
//
// * An optional of type FPOptionsOverride.
//
// Note that we store the offset in bytes from the this pointer to the start
// of the trailing objects. It would be perfectly possible to compute it
// based on the dynamic kind of the CallExpr. However 1.) we have plenty of
// space in the bit-fields of Stmt. 2.) It was benchmarked to be faster to
// compute this once and then load the offset from the bit-fields of Stmt,
// instead of re-computing the offset each time the trailing objects are
// accessed.

/// Return a pointer to the start of the trailing array of "Stmt *".
Stmt **getTrailingStmts() {
  return reinterpret_cast<Stmt **>(reinterpret_cast<char *>(this) +
                                   CallExprBits.OffsetToTrailingObjects);
}
Stmt *const *getTrailingStmts() const {
  return const_cast<CallExpr *>(this)->getTrailingStmts();
}

/// Map a statement class to the appropriate offset in bytes from the
/// this pointer to the trailing objects.
static unsigned offsetToTrailingObjects(StmtClass SC);

unsigned getSizeOfTrailingStmts() const {
  return (1 + getNumPreArgs() + getNumArgs()) * sizeof(Stmt *);
}

size_t getOffsetOfTrailingFPFeatures() const {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return CallExprBits.OffsetToTrailingObjects + getSizeOfTrailingStmts();
}

2850public:
enum class ADLCallKind : bool { NotADL, UsesADL };
static constexpr ADLCallKind NotADL = ADLCallKind::NotADL;
static constexpr ADLCallKind UsesADL = ADLCallKind::UsesADL;

2855protected:
/// Build a call expression, assuming that appropriate storage has been
/// allocated for the trailing objects.
CallExpr(StmtClass SC, Expr *Fn, ArrayRef<Expr *> PreArgs,
         ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
         SourceLocation RParenLoc, FPOptionsOverride FPFeatures,
         unsigned MinNumArgs, ADLCallKind UsesADL);

/// Build an empty call expression, for deserialization.
CallExpr(StmtClass SC, unsigned NumPreArgs, unsigned NumArgs,
         bool hasFPFeatures, EmptyShell Empty);

/// Return the size in bytes needed for the trailing objects.
/// Used by the derived classes to allocate the right amount of storage.
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs,
                                      bool HasFPFeatures) {
  return (1 + NumPreArgs + NumArgs) * sizeof(Stmt *) +
         HasFPFeatures * sizeof(FPOptionsOverride);
}

Stmt *getPreArg(unsigned I) {
  assert(I < getNumPreArgs() && "Prearg access out of range!")(static_cast<void> (0));
  return getTrailingStmts()[PREARGS_START + I];
}
const Stmt *getPreArg(unsigned I) const {
  assert(I < getNumPreArgs() && "Prearg access out of range!")(static_cast<void> (0));
  return getTrailingStmts()[PREARGS_START + I];
}
void setPreArg(unsigned I, Stmt *PreArg) {
  assert(I < getNumPreArgs() && "Prearg access out of range!")(static_cast<void> (0));
  getTrailingStmts()[PREARGS_START + I] = PreArg;
}

unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; }

/// Return a pointer to the trailing FPOptions
FPOptionsOverride *getTrailingFPFeatures() {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return reinterpret_cast<FPOptionsOverride *>(
      reinterpret_cast<char *>(this) + CallExprBits.OffsetToTrailingObjects +
      getSizeOfTrailingStmts());
}
const FPOptionsOverride *getTrailingFPFeatures() const {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return reinterpret_cast<const FPOptionsOverride *>(
      reinterpret_cast<const char *>(this) +
      CallExprBits.OffsetToTrailingObjects + getSizeOfTrailingStmts());
}

2904public:
/// Create a call expression.
/// \param Fn     The callee expression,
/// \param Args   The argument array,
/// \param Ty     The type of the call expression (which is *not* the return
///               type in general),
/// \param VK     The value kind of the call expression (lvalue, rvalue, ...),
/// \param RParenLoc  The location of the right parenthesis in the call
///                   expression.
/// \param FPFeatures Floating-point features associated with the call,
/// \param MinNumArgs Specifies the minimum number of arguments. The actual
///                   number of arguments will be the greater of Args.size()
///                   and MinNumArgs. This is used in a few places to allocate
///                   enough storage for the default arguments.
/// \param UsesADL    Specifies whether the callee was found through
///                   argument-dependent lookup.
///
/// Note that you can use CreateTemporary if you need a temporary call
/// expression on the stack.
static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
                        ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                        SourceLocation RParenLoc,
                        FPOptionsOverride FPFeatures, unsigned MinNumArgs = 0,
                        ADLCallKind UsesADL = NotADL);

/// Create a temporary call expression with no arguments in the memory
/// pointed to by Mem. Mem must points to at least sizeof(CallExpr)
/// + sizeof(Stmt *) bytes of storage, aligned to alignof(CallExpr):
///
/// \code{.cpp}
///   alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
///   CallExpr *TheCall = CallExpr::CreateTemporary(Buffer, etc);
/// \endcode
static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
                                 ExprValueKind VK, SourceLocation RParenLoc,
                                 ADLCallKind UsesADL = NotADL);

/// Create an empty call expression, for deserialization.
static CallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
                             bool HasFPFeatures, EmptyShell Empty);

Expr *getCallee() { return cast<Expr>(getTrailingStmts()[FN]); }
const Expr *getCallee() const { return cast<Expr>(getTrailingStmts()[FN]); }
void setCallee(Expr *F) { getTrailingStmts()[FN] = F; }

ADLCallKind getADLCallKind() const {
  return static_cast<ADLCallKind>(CallExprBits.UsesADL);
}
void setADLCallKind(ADLCallKind V = UsesADL) {
  CallExprBits.UsesADL = static_cast<bool>(V);
}
bool usesADL() const { return getADLCallKind() == UsesADL; }

bool hasStoredFPFeatures() const { return CallExprBits.HasFPFeatures; }

Decl *getCalleeDecl() { return getCallee()->getReferencedDeclOfCallee(); }
const Decl *getCalleeDecl() const {
  return getCallee()->getReferencedDeclOfCallee();
}

/// If the callee is a FunctionDecl, return it. Otherwise return null.
FunctionDecl *getDirectCallee() {
  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
}
const FunctionDecl *getDirectCallee() const {
  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
}

/// getNumArgs - Return the number of actual arguments to this call.
unsigned getNumArgs() const { return NumArgs; }

/// Retrieve the call arguments.
Expr **getArgs() {
  return reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START +
                                   getNumPreArgs());
}
const Expr *const *getArgs() const {
  return reinterpret_cast<const Expr *const *>(
      getTrailingStmts() + PREARGS_START + getNumPreArgs());
}

/// getArg - Return the specified argument.
Expr *getArg(unsigned Arg) {
  assert(Arg < getNumArgs() && "Arg access out of range!")(static_cast<void> (0));
  return getArgs()[Arg];
}
const Expr *getArg(unsigned Arg) const {
  assert(Arg < getNumArgs() && "Arg access out of range!")(static_cast<void> (0));
  return getArgs()[Arg];
}

/// setArg - Set the specified argument.
/// ! the dependence bits might be stale after calling this setter, it is
/// *caller*'s responsibility to recompute them by calling
/// computeDependence().
void setArg(unsigned Arg, Expr *ArgExpr) {
  assert(Arg < getNumArgs() && "Arg access out of range!")(static_cast<void> (0));
  getArgs()[Arg] = ArgExpr;
}

/// Compute and set dependence bits.
void computeDependence() {
  setDependence(clang::computeDependence(
      this, llvm::makeArrayRef(
                reinterpret_cast<Expr **>(getTrailingStmts() + PREARGS_START),
                getNumPreArgs())));
}

/// Reduce the number of arguments in this call expression. This is used for
/// example during error recovery to drop extra arguments. There is no way
/// to perform the opposite because: 1.) We don't track how much storage
/// we have for the argument array 2.) This would potentially require growing
/// the argument array, something we cannot support since the arguments are
/// stored in a trailing array.
void shrinkNumArgs(unsigned NewNumArgs) {
  assert((NewNumArgs <= getNumArgs()) &&(static_cast<void> (0))
         "shrinkNumArgs cannot increase the number of arguments!")(static_cast<void> (0));
  NumArgs = NewNumArgs;
}

/// Bluntly set a new number of arguments without doing any checks whatsoever.
/// Only used during construction of a CallExpr in a few places in Sema.
/// FIXME: Find a way to remove it.
void setNumArgsUnsafe(unsigned NewNumArgs) { NumArgs = NewNumArgs; }

typedef ExprIterator arg_iterator;
typedef ConstExprIterator const_arg_iterator;
typedef llvm::iterator_range<arg_iterator> arg_range;
typedef llvm::iterator_range<const_arg_iterator> const_arg_range;

arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
const_arg_range arguments() const {
  return const_arg_range(arg_begin(), arg_end());
}

arg_iterator arg_begin() {
  return getTrailingStmts() + PREARGS_START + getNumPreArgs();
}
arg_iterator arg_end() { return arg_begin() + getNumArgs(); }

const_arg_iterator arg_begin() const {
  return getTrailingStmts() + PREARGS_START + getNumPreArgs();
}
const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }

/// This method provides fast access to all the subexpressions of
/// a CallExpr without going through the slower virtual child_iterator
/// interface.  This provides efficient reverse iteration of the
/// subexpressions.  This is currently used for CFG construction.
ArrayRef<Stmt *> getRawSubExprs() {
  return llvm::makeArrayRef(getTrailingStmts(),
                            PREARGS_START + getNumPreArgs() + getNumArgs());
}

/// getNumCommas - Return the number of commas that must have been present in
/// this function call.
unsigned getNumCommas() const { return getNumArgs() ? getNumArgs() - 1 : 0; }

/// Get FPOptionsOverride from trailing storage.
FPOptionsOverride getStoredFPFeatures() const {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return *getTrailingFPFeatures();
}
/// Set FPOptionsOverride in trailing storage. Used only by Serialization.
void setStoredFPFeatures(FPOptionsOverride F) {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  *getTrailingFPFeatures() = F;
}

// Get the FP features status of this operator. Only meaningful for
// operations on floating point types.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const {
  if (hasStoredFPFeatures())
    return getStoredFPFeatures().applyOverrides(LO);
  return FPOptions::defaultWithoutTrailingStorage(LO);
}

FPOptionsOverride getFPFeatures() const {
  if (hasStoredFPFeatures())
    return getStoredFPFeatures();
  return FPOptionsOverride();
}

/// getBuiltinCallee - If this is a call to a builtin, return the builtin ID
/// of the callee. If not, return 0.
unsigned getBuiltinCallee() const;

/// Returns \c true if this is a call to a builtin which does not
/// evaluate side-effects within its arguments.
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const;

/// getCallReturnType - Get the return type of the call expr. This is not
/// always the type of the expr itself, if the return type is a reference
/// type.
QualType getCallReturnType(const ASTContext &Ctx) const;

/// Returns the WarnUnusedResultAttr that is either declared on the called
/// function, or its return type declaration.
const Attr *getUnusedResultAttr(const ASTContext &Ctx) const;

/// Returns true if this call expression should warn on unused results.
bool hasUnusedResultAttr(const ASTContext &Ctx) const {
  return getUnusedResultAttr(Ctx) != nullptr;
}

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

/// Return true if this is a call to __assume() or __builtin_assume() with
/// a non-value-dependent constant parameter evaluating as false.
bool isBuiltinAssumeFalse(const ASTContext &Ctx) const;

/// Used by Sema to implement MSVC-compatible delayed name lookup.
/// (Usually Exprs themselves should set dependence).
void markDependentForPostponedNameLookup() {
  setDependence(getDependence() | ExprDependence::TypeValueInstantiation);
}

bool isCallToStdMove() const {
  const FunctionDecl *FD = getDirectCallee();
  return getNumArgs() == 1 && FD && FD->isInStdNamespace() &&
         FD->getIdentifier() && FD->getIdentifier()->isStr("move");
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCallExprConstant &&
         T->getStmtClass() <= lastCallExprConstant;
}

// Iterators
child_range children() {
  return child_range(getTrailingStmts(), getTrailingStmts() + PREARGS_START +
                                             getNumPreArgs() + getNumArgs());
}

const_child_range children() const {
  return const_child_range(getTrailingStmts(),
                           getTrailingStmts() + PREARGS_START +
                               getNumPreArgs() + getNumArgs());
}
3147};

3149/// Extra data stored in some MemberExpr objects.
3150struct MemberExprNameQualifier {
/// The nested-name-specifier that qualifies the name, including
/// source-location information.
NestedNameSpecifierLoc QualifierLoc;

/// The DeclAccessPair through which the MemberDecl was found due to
/// name qualifiers.
DeclAccessPair FoundDecl;
3158};

3160/// MemberExpr - [C99 6.5.2.3] Structure and Union Members.  X->F and X.F.
3161///
3162class MemberExpr final
  : public Expr,
    private llvm::TrailingObjects<MemberExpr, MemberExprNameQualifier,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Base - the expression for the base pointer or structure references.  In
/// X.F, this is "X".
Stmt *Base;

/// MemberDecl - This is the decl being referenced by the field/member name.
/// In X.F, this is the decl referenced by F.
ValueDecl *MemberDecl;

/// MemberDNLoc - Provides source/type location info for the
/// declaration name embedded in MemberDecl.
DeclarationNameLoc MemberDNLoc;

/// MemberLoc - This is the location of the member name.
SourceLocation MemberLoc;

size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {
  return hasQualifierOrFoundDecl();
}

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

bool hasQualifierOrFoundDecl() const {
  return MemberExprBits.HasQualifierOrFoundDecl;
}

bool hasTemplateKWAndArgsInfo() const {
  return MemberExprBits.HasTemplateKWAndArgsInfo;
}

MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
           ValueDecl *MemberDecl, const DeclarationNameInfo &NameInfo,
           QualType T, ExprValueKind VK, ExprObjectKind OK,
           NonOdrUseReason NOUR);
MemberExpr(EmptyShell Empty)
    : Expr(MemberExprClass, Empty), Base(), MemberDecl() {}

3210public:
static MemberExpr *Create(const ASTContext &C, Expr *Base, bool IsArrow,
                          SourceLocation OperatorLoc,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
                          DeclAccessPair FoundDecl,
                          DeclarationNameInfo MemberNameInfo,
                          const TemplateArgumentListInfo *TemplateArgs,
                          QualType T, ExprValueKind VK, ExprObjectKind OK,
                          NonOdrUseReason NOUR);

/// Create an implicit MemberExpr, with no location, qualifier, template
/// arguments, and so on. Suitable only for non-static member access.
static MemberExpr *CreateImplicit(const ASTContext &C, Expr *Base,
                                  bool IsArrow, ValueDecl *MemberDecl,
                                  QualType T, ExprValueKind VK,
                                  ExprObjectKind OK) {
  return Create(C, Base, IsArrow, SourceLocation(), NestedNameSpecifierLoc(),
                SourceLocation(), MemberDecl,
                DeclAccessPair::make(MemberDecl, MemberDecl->getAccess()),
                DeclarationNameInfo(), nullptr, T, VK, OK, NOUR_None);
}

static MemberExpr *CreateEmpty(const ASTContext &Context, bool HasQualifier,
                               bool HasFoundDecl,
                               bool HasTemplateKWAndArgsInfo,
                               unsigned NumTemplateArgs);

void setBase(Expr *E) { Base = E; }
Expr *getBase() const { return cast<Expr>(Base); }

/// Retrieve the member declaration to which this expression refers.
///
/// The returned declaration will be a FieldDecl or (in C++) a VarDecl (for
/// static data members), a CXXMethodDecl, or an EnumConstantDecl.
ValueDecl *getMemberDecl() const { return MemberDecl; }
void setMemberDecl(ValueDecl *D);

/// Retrieves the declaration found by lookup.
DeclAccessPair getFoundDecl() const {
  if (!hasQualifierOrFoundDecl())
    return DeclAccessPair::make(getMemberDecl(),
                                getMemberDecl()->getAccess());
  return getTrailingObjects<MemberExprNameQualifier>()->FoundDecl;
}

/// Determines whether this member expression actually had
/// a C++ nested-name-specifier prior to the name of the member, e.g.,
/// x->Base::foo.
bool hasQualifier() const { return getQualifier() != nullptr; }

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name, with source-location
/// information.
NestedNameSpecifierLoc getQualifierLoc() const {
  if (!hasQualifierOrFoundDecl())
    return NestedNameSpecifierLoc();
  return getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc;
}

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name. Otherwise, returns
/// NULL.
NestedNameSpecifier *getQualifier() const {
  return getQualifierLoc().getNestedNameSpecifier();
}

/// Retrieve the location of the template keyword preceding
/// the member name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the member name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the member name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the member name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether the member name was followed by an
/// explicit template argument list.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

/// Retrieve the template arguments provided as part of this
/// template-id.
const TemplateArgumentLoc *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

/// Retrieve the number of template arguments provided as part of this
/// template-id.
unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Retrieve the member declaration name info.
DeclarationNameInfo getMemberNameInfo() const {
  return DeclarationNameInfo(MemberDecl->getDeclName(),
                             MemberLoc, MemberDNLoc);
}

SourceLocation getOperatorLoc() const { return MemberExprBits.OperatorLoc; }

bool isArrow() const { return MemberExprBits.IsArrow; }
void setArrow(bool A) { MemberExprBits.IsArrow = A; }

/// getMemberLoc - Return the location of the "member", in X->F, it is the
/// location of 'F'.
SourceLocation getMemberLoc() const { return MemberLoc; }
void setMemberLoc(SourceLocation L) { MemberLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return MemberLoc; }

/// Determine whether the base of this explicit is implicit.
bool isImplicitAccess() const {
  return getBase() && getBase()->isImplicitCXXThis();
}

/// Returns true if this member expression refers to a method that
/// was resolved from an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return MemberExprBits.HadMultipleCandidates;
}
/// Sets the flag telling whether this expression refers to
/// a method that was resolved from an overloaded set having size
/// greater than 1.
void setHadMultipleCandidates(bool V = true) {
  MemberExprBits.HadMultipleCandidates = V;
}

/// Returns true if virtual dispatch is performed.
/// If the member access is fully qualified, (i.e. X::f()), virtual
/// dispatching is not performed. In -fapple-kext mode qualified
/// calls to virtual method will still go through the vtable.
bool performsVirtualDispatch(const LangOptions &LO) const {
  return LO.AppleKext || !hasQualifier();
}

/// Is this expression a non-odr-use reference, and if so, why?
/// This is only meaningful if the named member is a static member.
NonOdrUseReason isNonOdrUse() const {
  return static_cast<NonOdrUseReason>(MemberExprBits.NonOdrUseReason);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MemberExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
3399};

3401/// CompoundLiteralExpr - [C99 6.5.2.5]
3402///
3403class CompoundLiteralExpr : public Expr {
/// LParenLoc - If non-null, this is the location of the left paren in a
/// compound literal like "(int){4}".  This can be null if this is a
/// synthesized compound expression.
SourceLocation LParenLoc;

/// The type as written.  This can be an incomplete array type, in
/// which case the actual expression type will be different.
/// The int part of the pair stores whether this expr is file scope.
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
Stmt *Init;
3414public:
CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo,
                    QualType T, ExprValueKind VK, Expr *init, bool fileScope)
    : Expr(CompoundLiteralExprClass, T, VK, OK_Ordinary),
      LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {
  setDependence(computeDependence(this));
}

/// Construct an empty compound literal.
explicit CompoundLiteralExpr(EmptyShell Empty)
  : Expr(CompoundLiteralExprClass, Empty) { }

const Expr *getInitializer() const { return cast<Expr>(Init); }
Expr *getInitializer() { return cast<Expr>(Init); }
void setInitializer(Expr *E) { Init = E; }

bool isFileScope() const { return TInfoAndScope.getInt(); }
void setFileScope(bool FS) { TInfoAndScope.setInt(FS); }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

TypeSourceInfo *getTypeSourceInfo() const {
  return TInfoAndScope.getPointer();
}
void setTypeSourceInfo(TypeSourceInfo *tinfo) {
  TInfoAndScope.setPointer(tinfo);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  if (LParenLoc.isInvalid())
    return Init->getBeginLoc();
  return LParenLoc;
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  // FIXME: Init should never be null.
  if (!Init)
    return SourceLocation();
  return Init->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CompoundLiteralExprClass;
}

// Iterators
child_range children() { return child_range(&Init, &Init+1); }
const_child_range children() const {
  return const_child_range(&Init, &Init + 1);
}
3467};

3469/// CastExpr - Base class for type casts, including both implicit
3470/// casts (ImplicitCastExpr) and explicit casts that have some
3471/// representation in the source code (ExplicitCastExpr's derived
3472/// classes).
3473class CastExpr : public Expr {
Stmt *Op;

bool CastConsistency() const;

const CXXBaseSpecifier * const *path_buffer() const {
  return const_cast<CastExpr*>(this)->path_buffer();
}
CXXBaseSpecifier **path_buffer();

friend class ASTStmtReader;

3485protected:
CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind,
         Expr *op, unsigned BasePathSize, bool HasFPFeatures)
    : Expr(SC, ty, VK, OK_Ordinary), Op(op) {
  CastExprBits.Kind = kind;
  CastExprBits.PartOfExplicitCast = false;
  CastExprBits.BasePathSize = BasePathSize;
  assert((CastExprBits.BasePathSize == BasePathSize) &&(static_cast<void> (0))
         "BasePathSize overflow!")(static_cast<void> (0));
  setDependence(computeDependence(this));
  assert(CastConsistency())(static_cast<void> (0));
  CastExprBits.HasFPFeatures = HasFPFeatures;
}

/// Construct an empty cast.
CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize,
         bool HasFPFeatures)
    : Expr(SC, Empty) {
  CastExprBits.PartOfExplicitCast = false;
  CastExprBits.BasePathSize = BasePathSize;
  CastExprBits.HasFPFeatures = HasFPFeatures;
  assert((CastExprBits.BasePathSize == BasePathSize) &&(static_cast<void> (0))
         "BasePathSize overflow!")(static_cast<void> (0));
}

/// Return a pointer to the trailing FPOptions.
/// \pre hasStoredFPFeatures() == true
FPOptionsOverride *getTrailingFPFeatures();
const FPOptionsOverride *getTrailingFPFeatures() const {
  return const_cast<CastExpr *>(this)->getTrailingFPFeatures();
}

3517public:
CastKind getCastKind() const { return (CastKind) CastExprBits.Kind; }
void setCastKind(CastKind K) { CastExprBits.Kind = K; }

static const char *getCastKindName(CastKind CK);
const char *getCastKindName() const { return getCastKindName(getCastKind()); }

Expr *getSubExpr() { return cast<Expr>(Op); }
const Expr *getSubExpr() const { return cast<Expr>(Op); }
void setSubExpr(Expr *E) { Op = E; }

/// Retrieve the cast subexpression as it was written in the source
/// code, looking through any implicit casts or other intermediate nodes
/// introduced by semantic analysis.
Expr *getSubExprAsWritten();
const Expr *getSubExprAsWritten() const {
  return const_cast<CastExpr *>(this)->getSubExprAsWritten();
}

/// If this cast applies a user-defined conversion, retrieve the conversion
/// function that it invokes.
NamedDecl *getConversionFunction() const;

typedef CXXBaseSpecifier **path_iterator;
typedef const CXXBaseSpecifier *const *path_const_iterator;
bool path_empty() const { return path_size() == 0; }
unsigned path_size() const { return CastExprBits.BasePathSize; }
path_iterator path_begin() { return path_buffer(); }
path_iterator path_end() { return path_buffer() + path_size(); }
path_const_iterator path_begin() const { return path_buffer(); }
path_const_iterator path_end() const { return path_buffer() + path_size(); }

llvm::iterator_range<path_iterator> path() {
  return llvm::make_range(path_begin(), path_end());
}
llvm::iterator_range<path_const_iterator> path() const {
  return llvm::make_range(path_begin(), path_end());
}

const FieldDecl *getTargetUnionField() const {
  assert(getCastKind() == CK_ToUnion)(static_cast<void> (0));
  return getTargetFieldForToUnionCast(getType(), getSubExpr()->getType());
}

bool hasStoredFPFeatures() const { return CastExprBits.HasFPFeatures; }

/// Get FPOptionsOverride from trailing storage.
FPOptionsOverride getStoredFPFeatures() const {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return *getTrailingFPFeatures();
}

// Get the FP features status of this operation. Only meaningful for
// operations on floating point types.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const {
  if (hasStoredFPFeatures())
    return getStoredFPFeatures().applyOverrides(LO);
  return FPOptions::defaultWithoutTrailingStorage(LO);
}

FPOptionsOverride getFPFeatures() const {
  if (hasStoredFPFeatures())
    return getStoredFPFeatures();
  return FPOptionsOverride();
}

static const FieldDecl *getTargetFieldForToUnionCast(QualType unionType,
                                                     QualType opType);
static const FieldDecl *getTargetFieldForToUnionCast(const RecordDecl *RD,
                                                     QualType opType);

static bool classof(const Stmt *T) {
  return T->getStmtClass() >= firstCastExprConstant &&
         T->getStmtClass() <= lastCastExprConstant;
}

// Iterators
child_range children() { return child_range(&Op, &Op+1); }
const_child_range children() const { return const_child_range(&Op, &Op + 1); }
3596};

3598/// ImplicitCastExpr - Allows us to explicitly represent implicit type
3599/// conversions, which have no direct representation in the original
3600/// source code. For example: converting T[]->T*, void f()->void
3601/// (*f)(), float->double, short->int, etc.
3602///
3603/// In C, implicit casts always produce rvalues. However, in C++, an
3604/// implicit cast whose result is being bound to a reference will be
3605/// an lvalue or xvalue. For example:
3606///
3607/// @code
3608/// class Base { };
3609/// class Derived : public Base { };
3610/// Derived &&ref();
3611/// void f(Derived d) {
3612///   Base& b = d; // initializer is an ImplicitCastExpr
3613///                // to an lvalue of type Base
3614///   Base&& r = ref(); // initializer is an ImplicitCastExpr
3615///                     // to an xvalue of type Base
3616/// }
3617/// @endcode
3618class ImplicitCastExpr final
  : public CastExpr,
    private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *,
                                  FPOptionsOverride> {

ImplicitCastExpr(QualType ty, CastKind kind, Expr *op,
                 unsigned BasePathLength, FPOptionsOverride FPO,
                 ExprValueKind VK)
    : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, BasePathLength,
               FPO.requiresTrailingStorage()) {
  if (hasStoredFPFeatures())
    *getTrailingFPFeatures() = FPO;
}

/// Construct an empty implicit cast.
explicit ImplicitCastExpr(EmptyShell Shell, unsigned PathSize,
                          bool HasFPFeatures)
    : CastExpr(ImplicitCastExprClass, Shell, PathSize, HasFPFeatures) {}

unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
  return path_size();
}

3641public:
enum OnStack_t { OnStack };
ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op,
                 ExprValueKind VK, FPOptionsOverride FPO)
    : CastExpr(ImplicitCastExprClass, ty, VK, kind, op, 0,
               FPO.requiresTrailingStorage()) {
  if (hasStoredFPFeatures())
    *getTrailingFPFeatures() = FPO;
}

bool isPartOfExplicitCast() const { return CastExprBits.PartOfExplicitCast; }
void setIsPartOfExplicitCast(bool PartOfExplicitCast) {
  CastExprBits.PartOfExplicitCast = PartOfExplicitCast;
}

static ImplicitCastExpr *Create(const ASTContext &Context, QualType T,
                                CastKind Kind, Expr *Operand,
                                const CXXCastPath *BasePath,
                                ExprValueKind Cat, FPOptionsOverride FPO);

static ImplicitCastExpr *CreateEmpty(const ASTContext &Context,
                                     unsigned PathSize, bool HasFPFeatures);

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
3677};

3679/// ExplicitCastExpr - An explicit cast written in the source
3680/// code.
3681///
3682/// This class is effectively an abstract class, because it provides
3683/// the basic representation of an explicitly-written cast without
3684/// specifying which kind of cast (C cast, functional cast, static
3685/// cast, etc.) was written; specific derived classes represent the
3686/// particular style of cast and its location information.
3687///
3688/// Unlike implicit casts, explicit cast nodes have two different
3689/// types: the type that was written into the source code, and the
3690/// actual type of the expression as determined by semantic
3691/// analysis. These types may differ slightly. For example, in C++ one
3692/// can cast to a reference type, which indicates that the resulting
3693/// expression will be an lvalue or xvalue. The reference type, however,
3694/// will not be used as the type of the expression.
3695class ExplicitCastExpr : public CastExpr {
/// TInfo - Source type info for the (written) type
/// this expression is casting to.
TypeSourceInfo *TInfo;

3700protected:
ExplicitCastExpr(StmtClass SC, QualType exprTy, ExprValueKind VK,
                 CastKind kind, Expr *op, unsigned PathSize,
                 bool HasFPFeatures, TypeSourceInfo *writtenTy)
    : CastExpr(SC, exprTy, VK, kind, op, PathSize, HasFPFeatures),
      TInfo(writtenTy) {}

/// Construct an empty explicit cast.
ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize,
                 bool HasFPFeatures)
    : CastExpr(SC, Shell, PathSize, HasFPFeatures) {}

3712public:
/// getTypeInfoAsWritten - Returns the type source info for the type
/// that this expression is casting to.
TypeSourceInfo *getTypeInfoAsWritten() const { return TInfo; }
void setTypeInfoAsWritten(TypeSourceInfo *writtenTy) { TInfo = writtenTy; }

/// getTypeAsWritten - Returns the type that this expression is
/// casting to, as written in the source code.
QualType getTypeAsWritten() const { return TInfo->getType(); }

static bool classof(const Stmt *T) {
   return T->getStmtClass() >= firstExplicitCastExprConstant &&
          T->getStmtClass() <= lastExplicitCastExprConstant;
}
3726};

3728/// CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style
3729/// cast in C++ (C++ [expr.cast]), which uses the syntax
3730/// (Type)expr. For example: @c (int)f.
3731class CStyleCastExpr final
  : public ExplicitCastExpr,
    private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *,
                                  FPOptionsOverride> {
SourceLocation LPLoc; // the location of the left paren
SourceLocation RPLoc; // the location of the right paren

CStyleCastExpr(QualType exprTy, ExprValueKind vk, CastKind kind, Expr *op,
               unsigned PathSize, FPOptionsOverride FPO,
               TypeSourceInfo *writtenTy, SourceLocation l, SourceLocation r)
    : ExplicitCastExpr(CStyleCastExprClass, exprTy, vk, kind, op, PathSize,
                       FPO.requiresTrailingStorage(), writtenTy),
      LPLoc(l), RPLoc(r) {
  if (hasStoredFPFeatures())
    *getTrailingFPFeatures() = FPO;
}

/// Construct an empty C-style explicit cast.
explicit CStyleCastExpr(EmptyShell Shell, unsigned PathSize,
                        bool HasFPFeatures)
    : ExplicitCastExpr(CStyleCastExprClass, Shell, PathSize, HasFPFeatures) {}

unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
  return path_size();
}

3757public:
static CStyleCastExpr *
Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K,
       Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO,
       TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R);

static CStyleCastExpr *CreateEmpty(const ASTContext &Context,
                                   unsigned PathSize, bool HasFPFeatures);

SourceLocation getLParenLoc() const { return LPLoc; }
void setLParenLoc(SourceLocation L) { LPLoc = L; }

SourceLocation getRParenLoc() const { return RPLoc; }
void setRParenLoc(SourceLocation L) { RPLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LPLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSubExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CStyleCastExprClass;
}

friend TrailingObjects;
friend class CastExpr;
3783};

3785/// A builtin binary operation expression such as "x + y" or "x <= y".
3786///
3787/// This expression node kind describes a builtin binary operation,
3788/// such as "x + y" for integer values "x" and "y". The operands will
3789/// already have been converted to appropriate types (e.g., by
3790/// performing promotions or conversions).
3791///
3792/// In C++, where operators may be overloaded, a different kind of
3793/// expression node (CXXOperatorCallExpr) is used to express the
3794/// invocation of an overloaded operator with operator syntax. Within
3795/// a C++ template, whether BinaryOperator or CXXOperatorCallExpr is
3796/// used to store an expression "x + y" depends on the subexpressions
3797/// for x and y. If neither x or y is type-dependent, and the "+"
3798/// operator resolves to a built-in operation, BinaryOperator will be
3799/// used to express the computation (x and y may still be
3800/// value-dependent). If either x or y is type-dependent, or if the
3801/// "+" resolves to an overloaded operator, CXXOperatorCallExpr will
3802/// be used to express the computation.
3803class BinaryOperator : public Expr {
enum { LHS, RHS, END_EXPR };
Stmt *SubExprs[END_EXPR];

3807public:
typedef BinaryOperatorKind Opcode;

3810protected:
size_t offsetOfTrailingStorage() const;

/// Return a pointer to the trailing FPOptions
FPOptionsOverride *getTrailingFPFeatures() {
  assert(BinaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
  return reinterpret_cast<FPOptionsOverride *>(
      reinterpret_cast<char *>(this) + offsetOfTrailingStorage());
}
const FPOptionsOverride *getTrailingFPFeatures() const {
  assert(BinaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
  return reinterpret_cast<const FPOptionsOverride *>(
      reinterpret_cast<const char *>(this) + offsetOfTrailingStorage());
}

/// Build a binary operator, assuming that appropriate storage has been
/// allocated for the trailing objects when needed.
BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc,
               QualType ResTy, ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptionsOverride FPFeatures);

/// Construct an empty binary operator.
explicit BinaryOperator(EmptyShell Empty) : Expr(BinaryOperatorClass, Empty) {
  BinaryOperatorBits.Opc = BO_Comma;
}

3836public:
static BinaryOperator *CreateEmpty(const ASTContext &C, bool hasFPFeatures);

static BinaryOperator *Create(const ASTContext &C, Expr *lhs, Expr *rhs,
                              Opcode opc, QualType ResTy, ExprValueKind VK,
                              ExprObjectKind OK, SourceLocation opLoc,
                              FPOptionsOverride FPFeatures);
SourceLocation getExprLoc() const { return getOperatorLoc(); }
SourceLocation getOperatorLoc() const { return BinaryOperatorBits.OpLoc; }
void setOperatorLoc(SourceLocation L) { BinaryOperatorBits.OpLoc = L; }

Opcode getOpcode() const {
  return static_cast<Opcode>(BinaryOperatorBits.Opc);
}
void setOpcode(Opcode Opc) { BinaryOperatorBits.Opc = Opc; }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getLHS()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getEndLoc();
}

/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
/// corresponds to, e.g. "<<=".
static StringRef getOpcodeStr(Opcode Op);

StringRef getOpcodeStr() const { return getOpcodeStr(getOpcode()); }

/// Retrieve the binary opcode that corresponds to the given
/// overloaded operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO);

/// Retrieve the overloaded operator kind that corresponds to
/// the given binary opcode.
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc);

/// predicates to categorize the respective opcodes.
static bool isPtrMemOp(Opcode Opc) {
  return Opc == BO_PtrMemD || Opc == BO_PtrMemI;
}
bool isPtrMemOp() const { return isPtrMemOp(getOpcode()); }

static bool isMultiplicativeOp(Opcode Opc) {
  return Opc >= BO_Mul && Opc <= BO_Rem;
}
bool isMultiplicativeOp() const { return isMultiplicativeOp(getOpcode()); }
static bool isAdditiveOp(Opcode Opc) { return Opc == BO_Add || Opc==BO_Sub; }
bool isAdditiveOp() const { return isAdditiveOp(getOpcode()); }
static bool isShiftOp(Opcode Opc) { return Opc == BO_Shl || Opc == BO_Shr; }
bool isShiftOp() const { return isShiftOp(getOpcode()); }

static bool isBitwiseOp(Opcode Opc) { return Opc >= BO_And && Opc <= BO_Or; }
bool isBitwiseOp() const { return isBitwiseOp(getOpcode()); }

static bool isRelationalOp(Opcode Opc) { return Opc >= BO_LT && Opc<=BO_GE; }
bool isRelationalOp() const { return isRelationalOp(getOpcode()); }

static bool isEqualityOp(Opcode Opc) { return Opc == BO_EQ || Opc == BO_NE; }
bool isEqualityOp() const { return isEqualityOp(getOpcode()); }

static bool isComparisonOp(Opcode Opc) { return Opc >= BO_Cmp && Opc<=BO_NE; }
bool isComparisonOp() const { return isComparisonOp(getOpcode()); }

static bool isCommaOp(Opcode Opc) { return Opc == BO_Comma; }
bool isCommaOp() const { return isCommaOp(getOpcode()); }

static Opcode negateComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")__builtin_unreachable();
  case BO_LT: return BO_GE;
  case BO_GT: return BO_LE;
  case BO_LE: return BO_GT;
  case BO_GE: return BO_LT;
  case BO_EQ: return BO_NE;
  case BO_NE: return BO_EQ;
  }
}

static Opcode reverseComparisonOp(Opcode Opc) {
  switch (Opc) {
  default:
    llvm_unreachable("Not a comparison operator.")__builtin_unreachable();
  case BO_LT: return BO_GT;
  case BO_GT: return BO_LT;
  case BO_LE: return BO_GE;
  case BO_GE: return BO_LE;
  case BO_EQ:
  case BO_NE:
    return Opc;
  }
}

static bool isLogicalOp(Opcode Opc) { return Opc == BO_LAnd || Opc==BO_LOr; }
bool isLogicalOp() const { return isLogicalOp(getOpcode()); }

static bool isAssignmentOp(Opcode Opc) {
  return Opc >= BO_Assign && Opc <= BO_OrAssign;
}
bool isAssignmentOp() const { return isAssignmentOp(getOpcode()); }

static bool isCompoundAssignmentOp(Opcode Opc) {
  return Opc > BO_Assign && Opc <= BO_OrAssign;
}
bool isCompoundAssignmentOp() const {
  return isCompoundAssignmentOp(getOpcode());
}
static Opcode getOpForCompoundAssignment(Opcode Opc) {
  assert(isCompoundAssignmentOp(Opc))(static_cast<void> (0));
  if (Opc >= BO_AndAssign)
    return Opcode(unsigned(Opc) - BO_AndAssign + BO_And);
  else
    return Opcode(unsigned(Opc) - BO_MulAssign + BO_Mul);
}

static bool isShiftAssignOp(Opcode Opc) {
  return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
}
bool isShiftAssignOp() const {
  return isShiftAssignOp(getOpcode());
}

// Return true if a binary operator using the specified opcode and operands
// would match the 'p = (i8*)nullptr + n' idiom for casting a pointer-sized
// integer to a pointer.
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc,
                                             Expr *LHS, Expr *RHS);

static bool classof(const Stmt *S) {
  return S->getStmtClass() >= firstBinaryOperatorConstant &&
         S->getStmtClass() <= lastBinaryOperatorConstant;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}

/// Set and fetch the bit that shows whether FPFeatures needs to be
/// allocated in Trailing Storage
void setHasStoredFPFeatures(bool B) { BinaryOperatorBits.HasFPFeatures = B; }
bool hasStoredFPFeatures() const { return BinaryOperatorBits.HasFPFeatures; }

/// Get FPFeatures from trailing storage
FPOptionsOverride getStoredFPFeatures() const {
  assert(hasStoredFPFeatures())(static_cast<void> (0));
  return *getTrailingFPFeatures();
}
/// Set FPFeatures in trailing storage, used only by Serialization
void setStoredFPFeatures(FPOptionsOverride F) {
  assert(BinaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
  *getTrailingFPFeatures() = F;
}

// Get the FP features status of this operator. Only meaningful for
// operations on floating point types.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const {
  if (BinaryOperatorBits.HasFPFeatures)
    return getStoredFPFeatures().applyOverrides(LO);
  return FPOptions::defaultWithoutTrailingStorage(LO);
}

// This is used in ASTImporter
FPOptionsOverride getFPFeatures(const LangOptions &LO) const {
  if (BinaryOperatorBits.HasFPFeatures)
    return getStoredFPFeatures();
  return FPOptionsOverride();
}

// Get the FP contractability status of this operator. Only meaningful for
// operations on floating point types.
bool isFPContractableWithinStatement(const LangOptions &LO) const {
  return getFPFeaturesInEffect(LO).allowFPContractWithinStatement();
}

// Get the FENV_ACCESS status of this operator. Only meaningful for
// operations on floating point types.
bool isFEnvAccessOn(const LangOptions &LO) const {
  return getFPFeaturesInEffect(LO).getAllowFEnvAccess();
}

4026protected:
BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc,
               QualType ResTy, ExprValueKind VK, ExprObjectKind OK,
               SourceLocation opLoc, FPOptionsOverride FPFeatures,
               bool dead2);

/// Construct an empty BinaryOperator, SC is CompoundAssignOperator.
BinaryOperator(StmtClass SC, EmptyShell Empty) : Expr(SC, Empty) {
  BinaryOperatorBits.Opc = BO_MulAssign;
}

/// Return the size in bytes needed for the trailing objects.
/// Used to allocate the right amount of storage.
static unsigned sizeOfTrailingObjects(bool HasFPFeatures) {
  return HasFPFeatures * sizeof(FPOptionsOverride);
}
4042};

4044/// CompoundAssignOperator - For compound assignments (e.g. +=), we keep
4045/// track of the type the operation is performed in.  Due to the semantics of
4046/// these operators, the operands are promoted, the arithmetic performed, an
4047/// implicit conversion back to the result type done, then the assignment takes
4048/// place.  This captures the intermediate type which the computation is done
4049/// in.
4050class CompoundAssignOperator : public BinaryOperator {
QualType ComputationLHSType;
QualType ComputationResultType;

/// Construct an empty CompoundAssignOperator.
explicit CompoundAssignOperator(const ASTContext &C, EmptyShell Empty,
                                bool hasFPFeatures)
    : BinaryOperator(CompoundAssignOperatorClass, Empty) {}

4059protected:
CompoundAssignOperator(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc,
                       QualType ResType, ExprValueKind VK, ExprObjectKind OK,
                       SourceLocation OpLoc, FPOptionsOverride FPFeatures,
                       QualType CompLHSType, QualType CompResultType)
    : BinaryOperator(C, lhs, rhs, opc, ResType, VK, OK, OpLoc, FPFeatures,
                     true),
      ComputationLHSType(CompLHSType), ComputationResultType(CompResultType) {
  assert(isCompoundAssignmentOp() &&(static_cast<void> (0))
         "Only should be used for compound assignments")(static_cast<void> (0));
}

4071public:
static CompoundAssignOperator *CreateEmpty(const ASTContext &C,
                                           bool hasFPFeatures);

static CompoundAssignOperator *
Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy,
       ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc,
       FPOptionsOverride FPFeatures, QualType CompLHSType = QualType(),
       QualType CompResultType = QualType());

// The two computation types are the type the LHS is converted
// to for the computation and the type of the result; the two are
// distinct in a few cases (specifically, int+=ptr and ptr-=ptr).
QualType getComputationLHSType() const { return ComputationLHSType; }
void setComputationLHSType(QualType T) { ComputationLHSType = T; }

QualType getComputationResultType() const { return ComputationResultType; }
void setComputationResultType(QualType T) { ComputationResultType = T; }

static bool classof(const Stmt *S) {
  return S->getStmtClass() == CompoundAssignOperatorClass;
}
4093};

4095inline size_t BinaryOperator::offsetOfTrailingStorage() const {
assert(BinaryOperatorBits.HasFPFeatures)(static_cast<void> (0));
return isa<CompoundAssignOperator>(this) ? sizeof(CompoundAssignOperator)
                                         : sizeof(BinaryOperator);
4099}

4101/// AbstractConditionalOperator - An abstract base class for
4102/// ConditionalOperator and BinaryConditionalOperator.
4103class AbstractConditionalOperator : public Expr {
SourceLocation QuestionLoc, ColonLoc;
friend class ASTStmtReader;

4107protected:
AbstractConditionalOperator(StmtClass SC, QualType T, ExprValueKind VK,
                            ExprObjectKind OK, SourceLocation qloc,
                            SourceLocation cloc)
    : Expr(SC, T, VK, OK), QuestionLoc(qloc), ColonLoc(cloc) {}

AbstractConditionalOperator(StmtClass SC, EmptyShell Empty)
  : Expr(SC, Empty) { }

4116public:
// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const;

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const;

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const;

SourceLocation getQuestionLoc() const { return QuestionLoc; }
SourceLocation getColonLoc() const { return ColonLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass ||
         T->getStmtClass() == BinaryConditionalOperatorClass;
}
4137};

4139/// ConditionalOperator - The ?: ternary operator.  The GNU "missing
4140/// middle" extension is a BinaryConditionalOperator.
4141class ConditionalOperator : public AbstractConditionalOperator {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.

friend class ASTStmtReader;
4146public:
ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs,
                    SourceLocation CLoc, Expr *rhs, QualType t,
                    ExprValueKind VK, ExprObjectKind OK)
    : AbstractConditionalOperator(ConditionalOperatorClass, t, VK, OK, QLoc,
                                  CLoc) {
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  setDependence(computeDependence(this));
}

/// Build an empty conditional operator.
explicit ConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(ConditionalOperatorClass, Empty) { }

// getCond - Return the expression representing the condition for
//   the ?: operator.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

// getTrueExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to true.
Expr *getTrueExpr() const { return cast<Expr>(SubExprs[LHS]); }

// getFalseExpr - Return the subexpression representing the value of
//   the expression if the condition evaluates to false.  This is
//   the same as getRHS.
Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }

Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCond()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getRHS()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
4196};

4198/// BinaryConditionalOperator - The GNU extension to the conditional
4199/// operator which allows the middle operand to be omitted.
4200///
4201/// This is a different expression kind on the assumption that almost
4202/// every client ends up needing to know that these are different.
4203class BinaryConditionalOperator : public AbstractConditionalOperator {
enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };

/// - the common condition/left-hand-side expression, which will be
///   evaluated as the opaque value
/// - the condition, expressed in terms of the opaque value
/// - the left-hand-side, expressed in terms of the opaque value
/// - the right-hand-side
Stmt *SubExprs[NUM_SUBEXPRS];
OpaqueValueExpr *OpaqueValue;

friend class ASTStmtReader;
4215public:
BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue,
                          Expr *cond, Expr *lhs, Expr *rhs,
                          SourceLocation qloc, SourceLocation cloc,
                          QualType t, ExprValueKind VK, ExprObjectKind OK)
    : AbstractConditionalOperator(BinaryConditionalOperatorClass, t, VK, OK,
                                  qloc, cloc),
      OpaqueValue(opaqueValue) {
  SubExprs[COMMON] = common;
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;
  assert(OpaqueValue->getSourceExpr() == common && "Wrong opaque value")(static_cast<void> (0));
  setDependence(computeDependence(this));
}

/// Build an empty conditional operator.
explicit BinaryConditionalOperator(EmptyShell Empty)
  : AbstractConditionalOperator(BinaryConditionalOperatorClass, Empty) { }

/// getCommon - Return the common expression, written to the
///   left of the condition.  The opaque value will be bound to the
///   result of this expression.
Expr *getCommon() const { return cast<Expr>(SubExprs[COMMON]); }

/// getOpaqueValue - Return the opaque value placeholder.
OpaqueValueExpr *getOpaqueValue() const { return OpaqueValue; }

/// getCond - Return the condition expression; this is defined
///   in terms of the opaque value.
Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }

/// getTrueExpr - Return the subexpression which will be
///   evaluated if the condition evaluates to true;  this is defined
///   in terms of the opaque value.
Expr *getTrueExpr() const {
  return cast<Expr>(SubExprs[LHS]);
}

/// getFalseExpr - Return the subexpression which will be
///   evaluated if the condnition evaluates to false; this is
///   defined in terms of the opaque value.
Expr *getFalseExpr() const {
  return cast<Expr>(SubExprs[RHS]);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommon()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getFalseExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BinaryConditionalOperatorClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
}
4279};

4281inline Expr *AbstractConditionalOperator::getCond() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getCond();
return cast<BinaryConditionalOperator>(this)->getCond();
4285}

4287inline Expr *AbstractConditionalOperator::getTrueExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getTrueExpr();
return cast<BinaryConditionalOperator>(this)->getTrueExpr();
4291}

4293inline Expr *AbstractConditionalOperator::getFalseExpr() const {
if (const ConditionalOperator *co = dyn_cast<ConditionalOperator>(this))
  return co->getFalseExpr();
return cast<BinaryConditionalOperator>(this)->getFalseExpr();
4297}

4299/// AddrLabelExpr - The GNU address of label extension, representing &&label.
4300class AddrLabelExpr : public Expr {
SourceLocation AmpAmpLoc, LabelLoc;
LabelDecl *Label;
4303public:
AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L,
              QualType t)
    : Expr(AddrLabelExprClass, t, VK_PRValue, OK_Ordinary), AmpAmpLoc(AALoc),
      LabelLoc(LLoc), Label(L) {
  setDependence(ExprDependence::None);
}

/// Build an empty address of a label expression.
explicit AddrLabelExpr(EmptyShell Empty)
  : Expr(AddrLabelExprClass, Empty) { }

SourceLocation getAmpAmpLoc() const { return AmpAmpLoc; }
void setAmpAmpLoc(SourceLocation L) { AmpAmpLoc = L; }
SourceLocation getLabelLoc() const { return LabelLoc; }
void setLabelLoc(SourceLocation L) { LabelLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return AmpAmpLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return LabelLoc; }

LabelDecl *getLabel() const { return Label; }
void setLabel(LabelDecl *L) { Label = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AddrLabelExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4337};

4339/// StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
4340/// The StmtExpr contains a single CompoundStmt node, which it evaluates and
4341/// takes the value of the last subexpression.
4342///
4343/// A StmtExpr is always an r-value; values "returned" out of a
4344/// StmtExpr will be copied.
4345class StmtExpr : public Expr {
Stmt *SubStmt;
SourceLocation LParenLoc, RParenLoc;
4348public:
StmtExpr(CompoundStmt *SubStmt, QualType T, SourceLocation LParenLoc,
         SourceLocation RParenLoc, unsigned TemplateDepth)
    : Expr(StmtExprClass, T, VK_PRValue, OK_Ordinary), SubStmt(SubStmt),
      LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
  setDependence(computeDependence(this, TemplateDepth));
  // FIXME: A templated statement expression should have an associated
  // DeclContext so that nested declarations always have a dependent context.
  StmtExprBits.TemplateDepth = TemplateDepth;
}

/// Build an empty statement expression.
explicit StmtExpr(EmptyShell Empty) : Expr(StmtExprClass, Empty) { }

CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
void setSubStmt(CompoundStmt *S) { SubStmt = S; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return LParenLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

unsigned getTemplateDepth() const { return StmtExprBits.TemplateDepth; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == StmtExprClass;
}

// Iterators
child_range children() { return child_range(&SubStmt, &SubStmt+1); }
const_child_range children() const {
  return const_child_range(&SubStmt, &SubStmt + 1);
}
4385};

4387/// ShuffleVectorExpr - clang-specific builtin-in function
4388/// __builtin_shufflevector.
4389/// This AST node represents a operator that does a constant
4390/// shuffle, similar to LLVM's shufflevector instruction. It takes
4391/// two vectors and a variable number of constant indices,
4392/// and returns the appropriately shuffled vector.
4393class ShuffleVectorExpr : public Expr {
SourceLocation BuiltinLoc, RParenLoc;

// SubExprs - the list of values passed to the __builtin_shufflevector
// function. The first two are vectors, and the rest are constant
// indices.  The number of values in this list is always
// 2+the number of indices in the vector type.
Stmt **SubExprs;
unsigned NumExprs;

4403public:
ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
                  SourceLocation BLoc, SourceLocation RP);

/// Build an empty vector-shuffle expression.
explicit ShuffleVectorExpr(EmptyShell Empty)
  : Expr(ShuffleVectorExprClass, Empty), SubExprs(nullptr) { }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ShuffleVectorExprClass;
}

/// getNumSubExprs - Return the size of the SubExprs array.  This includes the
/// constant expression, the actual arguments passed in, and the function
/// pointers.
unsigned getNumSubExprs() const { return NumExprs; }

/// Retrieve the array of expressions.
Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }

/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
  assert((Index < NumExprs) && "Arg access out of range!")(static_cast<void> (0));
  return cast<Expr>(SubExprs[Index]);
}
const Expr *getExpr(unsigned Index) const {
  assert((Index < NumExprs) && "Arg access out of range!")(static_cast<void> (0));
  return cast<Expr>(SubExprs[Index]);
}

void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);

llvm::APSInt getShuffleMaskIdx(const ASTContext &Ctx, unsigned N) const {
  assert((N < NumExprs - 2) && "Shuffle idx out of range!")(static_cast<void> (0));
  return getExpr(N+2)->EvaluateKnownConstInt(Ctx);
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
}
4456};

4458/// ConvertVectorExpr - Clang builtin function __builtin_convertvector
4459/// This AST node provides support for converting a vector type to another
4460/// vector type of the same arity.
4461class ConvertVectorExpr : public Expr {
4462private:
Stmt *SrcExpr;
TypeSourceInfo *TInfo;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit ConvertVectorExpr(EmptyShell Empty) : Expr(ConvertVectorExprClass, Empty) {}

4471public:
ConvertVectorExpr(Expr *SrcExpr, TypeSourceInfo *TI, QualType DstType,
                  ExprValueKind VK, ExprObjectKind OK,
                  SourceLocation BuiltinLoc, SourceLocation RParenLoc)
    : Expr(ConvertVectorExprClass, DstType, VK, OK), SrcExpr(SrcExpr),
      TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {
  setDependence(computeDependence(this));
}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getTypeSourceInfo - Return the destination type.
TypeSourceInfo *getTypeSourceInfo() const {
  return TInfo;
}
void setTypeSourceInfo(TypeSourceInfo *ti) {
  TInfo = ti;
}

/// getBuiltinLoc - Return the location of the __builtin_convertvector token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ConvertVectorExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
4509};

4511/// ChooseExpr - GNU builtin-in function __builtin_choose_expr.
4512/// This AST node is similar to the conditional operator (?:) in C, with
4513/// the following exceptions:
4514/// - the test expression must be a integer constant expression.
4515/// - the expression returned acts like the chosen subexpression in every
4516///   visible way: the type is the same as that of the chosen subexpression,
4517///   and all predicates (whether it's an l-value, whether it's an integer
4518///   constant expression, etc.) return the same result as for the chosen
4519///   sub-expression.
4520class ChooseExpr : public Expr {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
SourceLocation BuiltinLoc, RParenLoc;
bool CondIsTrue;
4525public:
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t,
           ExprValueKind VK, ExprObjectKind OK, SourceLocation RP,
           bool condIsTrue)
    : Expr(ChooseExprClass, t, VK, OK), BuiltinLoc(BLoc), RParenLoc(RP),
      CondIsTrue(condIsTrue) {
  SubExprs[COND] = cond;
  SubExprs[LHS] = lhs;
  SubExprs[RHS] = rhs;

  setDependence(computeDependence(this));
}

/// Build an empty __builtin_choose_expr.
explicit ChooseExpr(EmptyShell Empty) : Expr(ChooseExprClass, Empty) { }

/// isConditionTrue - Return whether the condition is true (i.e. not
/// equal to zero).
bool isConditionTrue() const {
  assert(!isConditionDependent() &&(static_cast<void> (0))
         "Dependent condition isn't true or false")(static_cast<void> (0));
  return CondIsTrue;
}
void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }

bool isConditionDependent() const {
  return getCond()->isTypeDependent() || getCond()->isValueDependent();
}

/// getChosenSubExpr - Return the subexpression chosen according to the
/// condition.
Expr *getChosenSubExpr() const {
  return isConditionTrue() ? getLHS() : getRHS();
}

Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
void setCond(Expr *E) { SubExprs[COND] = E; }
Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
void setLHS(Expr *E) { SubExprs[LHS] = E; }
Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
void setRHS(Expr *E) { SubExprs[RHS] = E; }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ChooseExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
}
const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
}
4587};

4589/// GNUNullExpr - Implements the GNU __null extension, which is a name
4590/// for a null pointer constant that has integral type (e.g., int or
4591/// long) and is the same size and alignment as a pointer. The __null
4592/// extension is typically only used by system headers, which define
4593/// NULL as __null in C++ rather than using 0 (which is an integer
4594/// that may not match the size of a pointer).
4595class GNUNullExpr : public Expr {
/// TokenLoc - The location of the __null keyword.
SourceLocation TokenLoc;

4599public:
GNUNullExpr(QualType Ty, SourceLocation Loc)
    : Expr(GNUNullExprClass, Ty, VK_PRValue, OK_Ordinary), TokenLoc(Loc) {
  setDependence(ExprDependence::None);
}

/// Build an empty GNU __null expression.
explicit GNUNullExpr(EmptyShell Empty) : Expr(GNUNullExprClass, Empty) { }

/// getTokenLocation - The location of the __null token.
SourceLocation getTokenLocation() const { return TokenLoc; }
void setTokenLocation(SourceLocation L) { TokenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return TokenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GNUNullExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
4626};

4628/// Represents a call to the builtin function \c __builtin_va_arg.
4629class VAArgExpr : public Expr {
Stmt *Val;
llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
SourceLocation BuiltinLoc, RParenLoc;
4633public:
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
          SourceLocation RPLoc, QualType t, bool IsMS)
    : Expr(VAArgExprClass, t, VK_PRValue, OK_Ordinary), Val(e),
      TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {
  setDependence(computeDependence(this));
}

/// Create an empty __builtin_va_arg expression.
explicit VAArgExpr(EmptyShell Empty)
    : Expr(VAArgExprClass, Empty), Val(nullptr), TInfo(nullptr, false) {}

const Expr *getSubExpr() const { return cast<Expr>(Val); }
Expr *getSubExpr() { return cast<Expr>(Val); }
void setSubExpr(Expr *E) { Val = E; }

/// Returns whether this is really a Win64 ABI va_arg expression.
bool isMicrosoftABI() const { return TInfo.getInt(); }
void setIsMicrosoftABI(bool IsMS) { TInfo.setInt(IsMS); }

TypeSourceInfo *getWrittenTypeInfo() const { return TInfo.getPointer(); }
void setWrittenTypeInfo(TypeSourceInfo *TI) { TInfo.setPointer(TI); }

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }

SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == VAArgExprClass;
}

// Iterators
child_range children() { return child_range(&Val, &Val+1); }
const_child_range children() const {
  return const_child_range(&Val, &Val + 1);
}
4674};

4676/// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
4677/// __builtin_FUNCTION(), or __builtin_FILE().
4678class SourceLocExpr final : public Expr {
SourceLocation BuiltinLoc, RParenLoc;
DeclContext *ParentContext;

4682public:
enum IdentKind { Function, File, Line, Column };

SourceLocExpr(const ASTContext &Ctx, IdentKind Type, SourceLocation BLoc,
              SourceLocation RParenLoc, DeclContext *Context);

/// Build an empty call expression.
explicit SourceLocExpr(EmptyShell Empty) : Expr(SourceLocExprClass, Empty) {}

/// Return the result of evaluating this SourceLocExpr in the specified
/// (and possibly null) default argument or initialization context.
APValue EvaluateInContext(const ASTContext &Ctx,
                          const Expr *DefaultExpr) const;

/// Return a string representing the name of the specific builtin function.
StringRef getBuiltinStr() const;

IdentKind getIdentKind() const {
  return static_cast<IdentKind>(SourceLocExprBits.Kind);
}

bool isStringType() const {
  switch (getIdentKind()) {
  case File:
  case Function:
    return true;
  case Line:
  case Column:
    return false;
  }
  llvm_unreachable("unknown source location expression kind")__builtin_unreachable();
}
bool isIntType() const LLVM_READONLY__attribute__((__pure__)) { return !isStringType(); }

/// If the SourceLocExpr has been resolved return the subexpression
/// representing the resolved value. Otherwise return null.
const DeclContext *getParentContext() const { return ParentContext; }
DeclContext *getParentContext() { return ParentContext; }

SourceLocation getLocation() const { return BuiltinLoc; }
SourceLocation getBeginLoc() const { return BuiltinLoc; }
SourceLocation getEndLoc() const { return RParenLoc; }

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(child_iterator(), child_iterator());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == SourceLocExprClass;
}

4737private:
friend class ASTStmtReader;
4739};

4741/// Describes an C or C++ initializer list.
4742///
4743/// InitListExpr describes an initializer list, which can be used to
4744/// initialize objects of different types, including
4745/// struct/class/union types, arrays, and vectors. For example:
4746///
4747/// @code
4748/// struct foo x = { 1, { 2, 3 } };
4749/// @endcode
4750///
4751/// Prior to semantic analysis, an initializer list will represent the
4752/// initializer list as written by the user, but will have the
4753/// placeholder type "void". This initializer list is called the
4754/// syntactic form of the initializer, and may contain C99 designated
4755/// initializers (represented as DesignatedInitExprs), initializations
4756/// of subobject members without explicit braces, and so on. Clients
4757/// interested in the original syntax of the initializer list should
4758/// use the syntactic form of the initializer list.
4759///
4760/// After semantic analysis, the initializer list will represent the
4761/// semantic form of the initializer, where the initializations of all
4762/// subobjects are made explicit with nested InitListExpr nodes and
4763/// C99 designators have been eliminated by placing the designated
4764/// initializations into the subobject they initialize. Additionally,
4765/// any "holes" in the initialization, where no initializer has been
4766/// specified for a particular subobject, will be replaced with
4767/// implicitly-generated ImplicitValueInitExpr expressions that
4768/// value-initialize the subobjects. Note, however, that the
4769/// initializer lists may still have fewer initializers than there are
4770/// elements to initialize within the object.
4771///
4772/// After semantic analysis has completed, given an initializer list,
4773/// method isSemanticForm() returns true if and only if this is the
4774/// semantic form of the initializer list (note: the same AST node
4775/// may at the same time be the syntactic form).
4776/// Given the semantic form of the initializer list, one can retrieve
4777/// the syntactic form of that initializer list (when different)
4778/// using method getSyntacticForm(); the method returns null if applied
4779/// to a initializer list which is already in syntactic form.
4780/// Similarly, given the syntactic form (i.e., an initializer list such
4781/// that isSemanticForm() returns false), one can retrieve the semantic
4782/// form using method getSemanticForm().
4783/// Since many initializer lists have the same syntactic and semantic forms,
4784/// getSyntacticForm() may return NULL, indicating that the current
4785/// semantic initializer list also serves as its syntactic form.
4786class InitListExpr : public Expr {
// FIXME: Eliminate this vector in favor of ASTContext allocation
typedef ASTVector<Stmt *> InitExprsTy;
InitExprsTy InitExprs;
SourceLocation LBraceLoc, RBraceLoc;

/// The alternative form of the initializer list (if it exists).
/// The int part of the pair stores whether this initializer list is
/// in semantic form. If not null, the pointer points to:
///   - the syntactic form, if this is in semantic form;
///   - the semantic form, if this is in syntactic form.
llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;

/// Either:
///  If this initializer list initializes an array with more elements than
///  there are initializers in the list, specifies an expression to be used
///  for value initialization of the rest of the elements.
/// Or
///  If this initializer list initializes a union, specifies which
///  field within the union will be initialized.
llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;

4808public:
InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
             ArrayRef<Expr*> initExprs, SourceLocation rbraceloc);

/// Build an empty initializer list.
explicit InitListExpr(EmptyShell Empty)
  : Expr(InitListExprClass, Empty), AltForm(nullptr, true) { }

unsigned getNumInits() const { return InitExprs.size(); }

/// Retrieve the set of initializers.
Expr **getInits() { return reinterpret_cast<Expr **>(InitExprs.data()); }

/// Retrieve the set of initializers.
Expr * const *getInits() const {
  return reinterpret_cast<Expr * const *>(InitExprs.data());
}

ArrayRef<Expr *> inits() {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

ArrayRef<Expr *> inits() const {
  return llvm::makeArrayRef(getInits(), getNumInits());
}

const Expr *getInit(unsigned Init) const {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast<void> (0));
  return cast_or_null<Expr>(InitExprs[Init]);
}

Expr *getInit(unsigned Init) {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast<void> (0));
  return cast_or_null<Expr>(InitExprs[Init]);
}

void setInit(unsigned Init, Expr *expr) {
  assert(Init < getNumInits() && "Initializer access out of range!")(static_cast<void> (0));
  InitExprs[Init] = expr;

  if (expr)
    setDependence(getDependence() | expr->getDependence());
}

/// Mark the semantic form of the InitListExpr as error when the semantic
/// analysis fails.
void markError() {
  assert(isSemanticForm())(static_cast<void> (0));
  setDependence(getDependence() | ExprDependence::ErrorDependent);
}

/// Reserve space for some number of initializers.
void reserveInits(const ASTContext &C, unsigned NumInits);

/// Specify the number of initializers
///
/// If there are more than @p NumInits initializers, the remaining
/// initializers will be destroyed. If there are fewer than @p
/// NumInits initializers, NULL expressions will be added for the
/// unknown initializers.
void resizeInits(const ASTContext &Context, unsigned NumInits);

/// Updates the initializer at index @p Init with the new
/// expression @p expr, and returns the old expression at that
/// location.
///
/// When @p Init is out of range for this initializer list, the
/// initializer list will be extended with NULL expressions to
/// accommodate the new entry.
Expr *updateInit(const ASTContext &C, unsigned Init, Expr *expr);

/// If this initializer list initializes an array with more elements
/// than there are initializers in the list, specifies an expression to be
/// used for value initialization of the rest of the elements.
Expr *getArrayFiller() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<Expr *>();
}
const Expr *getArrayFiller() const {
  return const_cast<InitListExpr *>(this)->getArrayFiller();
}
void setArrayFiller(Expr *filler);

/// Return true if this is an array initializer and its array "filler"
/// has been set.
bool hasArrayFiller() const { return getArrayFiller(); }

/// If this initializes a union, specifies which field in the
/// union to initialize.
///
/// Typically, this field is the first named field within the
/// union. However, a designated initializer can specify the
/// initialization of a different field within the union.
FieldDecl *getInitializedFieldInUnion() {
  return ArrayFillerOrUnionFieldInit.dyn_cast<FieldDecl *>();
}
const FieldDecl *getInitializedFieldInUnion() const {
  return const_cast<InitListExpr *>(this)->getInitializedFieldInUnion();
}
void setInitializedFieldInUnion(FieldDecl *FD) {
  assert((FD == nullptr(static_cast<void> (0))
          || getInitializedFieldInUnion() == nullptr(static_cast<void> (0))
          || getInitializedFieldInUnion() == FD)(static_cast<void> (0))
         && "Only one field of a union may be initialized at a time!")(static_cast<void> (0));
  ArrayFillerOrUnionFieldInit = FD;
}

// Explicit InitListExpr's originate from source code (and have valid source
// locations). Implicit InitListExpr's are created by the semantic analyzer.
// FIXME: This is wrong; InitListExprs created by semantic analysis have
// valid source locations too!
bool isExplicit() const {
  return LBraceLoc.isValid() && RBraceLoc.isValid();
}

// Is this an initializer for an array of characters, initialized by a string
// literal or an @encode?
bool isStringLiteralInit() const;

/// Is this a transparent initializer list (that is, an InitListExpr that is
/// purely syntactic, and whose semantics are that of the sole contained
/// initializer)?
bool isTransparent() const;

/// Is this the zero initializer {0} in a language which considers it
/// idiomatic?
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const;

SourceLocation getLBraceLoc() const { return LBraceLoc; }
void setLBraceLoc(SourceLocation Loc) { LBraceLoc = Loc; }
SourceLocation getRBraceLoc() const { return RBraceLoc; }
void setRBraceLoc(SourceLocation Loc) { RBraceLoc = Loc; }

bool isSemanticForm() const { return AltForm.getInt(); }
InitListExpr *getSemanticForm() const {
  return isSemanticForm() ? nullptr : AltForm.getPointer();
}
bool isSyntacticForm() const {
  return !AltForm.getInt() || !AltForm.getPointer();
}
InitListExpr *getSyntacticForm() const {
  return isSemanticForm() ? AltForm.getPointer() : nullptr;
}

void setSyntacticForm(InitListExpr *Init) {
  AltForm.setPointer(Init);
  AltForm.setInt(true);
  Init->AltForm.setPointer(this);
  Init->AltForm.setInt(false);
}

bool hadArrayRangeDesignator() const {
  return InitListExprBits.HadArrayRangeDesignator != 0;
}
void sawArrayRangeDesignator(bool ARD = true) {
  InitListExprBits.HadArrayRangeDesignator = ARD;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == InitListExprClass;
}

// Iterators
child_range children() {
  const_child_range CCR = const_cast<const InitListExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}

const_child_range children() const {
  // FIXME: This does not include the array filler expression.
  if (InitExprs.empty())
    return const_child_range(const_child_iterator(), const_child_iterator());
  return const_child_range(&InitExprs[0], &InitExprs[0] + InitExprs.size());
}

typedef InitExprsTy::iterator iterator;
typedef InitExprsTy::const_iterator const_iterator;
typedef InitExprsTy::reverse_iterator reverse_iterator;
typedef InitExprsTy::const_reverse_iterator const_reverse_iterator;

iterator begin() { return InitExprs.begin(); }
const_iterator begin() const { return InitExprs.begin(); }
iterator end() { return InitExprs.end(); }
const_iterator end() const { return InitExprs.end(); }
reverse_iterator rbegin() { return InitExprs.rbegin(); }
const_reverse_iterator rbegin() const { return InitExprs.rbegin(); }
reverse_iterator rend() { return InitExprs.rend(); }
const_reverse_iterator rend() const { return InitExprs.rend(); }

friend class ASTStmtReader;
friend class ASTStmtWriter;
5002};

5004/// Represents a C99 designated initializer expression.
5005///
5006/// A designated initializer expression (C99 6.7.8) contains one or
5007/// more designators (which can be field designators, array
5008/// designators, or GNU array-range designators) followed by an
5009/// expression that initializes the field or element(s) that the
5010/// designators refer to. For example, given:
5011///
5012/// @code
5013/// struct point {
5014///   double x;
5015///   double y;
5016/// };
5017/// struct point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
5018/// @endcode
5019///
5020/// The InitListExpr contains three DesignatedInitExprs, the first of
5021/// which covers @c [2].y=1.0. This DesignatedInitExpr will have two
5022/// designators, one array designator for @c [2] followed by one field
5023/// designator for @c .y. The initialization expression will be 1.0.
5024class DesignatedInitExpr final
  : public Expr,
    private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
5027public:
/// Forward declaration of the Designator class.
class Designator;

5031private:
/// The location of the '=' or ':' prior to the actual initializer
/// expression.
SourceLocation EqualOrColonLoc;

/// Whether this designated initializer used the GNU deprecated
/// syntax rather than the C99 '=' syntax.
unsigned GNUSyntax : 1;

/// The number of designators in this initializer expression.
unsigned NumDesignators : 15;

/// The number of subexpressions of this initializer expression,
/// which contains both the initializer and any additional
/// expressions used by array and array-range designators.
unsigned NumSubExprs : 16;

/// The designators in this designated initialization
/// expression.
Designator *Designators;

DesignatedInitExpr(const ASTContext &C, QualType Ty,
                   llvm::ArrayRef<Designator> Designators,
                   SourceLocation EqualOrColonLoc, bool GNUSyntax,
                   ArrayRef<Expr *> IndexExprs, Expr *Init);

explicit DesignatedInitExpr(unsigned NumSubExprs)
  : Expr(DesignatedInitExprClass, EmptyShell()),
    NumDesignators(0), NumSubExprs(NumSubExprs), Designators(nullptr) { }

5061public:
/// A field designator, e.g., ".x".
struct FieldDesignator {
  /// Refers to the field that is being initialized. The low bit
  /// of this field determines whether this is actually a pointer
  /// to an IdentifierInfo (if 1) or a FieldDecl (if 0). When
  /// initially constructed, a field designator will store an
  /// IdentifierInfo*. After semantic analysis has resolved that
  /// name, the field designator will instead store a FieldDecl*.
  uintptr_t NameOrField;

  /// The location of the '.' in the designated initializer.
  SourceLocation DotLoc;

  /// The location of the field name in the designated initializer.
  SourceLocation FieldLoc;
};

/// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
struct ArrayOrRangeDesignator {
  /// Location of the first index expression within the designated
  /// initializer expression's list of subexpressions.
  unsigned Index;
  /// The location of the '[' starting the array range designator.
  SourceLocation LBracketLoc;
  /// The location of the ellipsis separating the start and end
  /// indices. Only valid for GNU array-range designators.
  SourceLocation EllipsisLoc;
  /// The location of the ']' terminating the array range designator.
  SourceLocation RBracketLoc;
};

/// Represents a single C99 designator.
///
/// @todo This class is infuriatingly similar to clang::Designator,
/// but minor differences (storing indices vs. storing pointers)
/// keep us from reusing it. Try harder, later, to rectify these
/// differences.
class Designator {
  /// The kind of designator this describes.
  enum {
    FieldDesignator,
    ArrayDesignator,
    ArrayRangeDesignator
  } Kind;

  union {
    /// A field designator, e.g., ".x".
    struct FieldDesignator Field;
    /// An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
    struct ArrayOrRangeDesignator ArrayOrRange;
  };
  friend class DesignatedInitExpr;

public:
  Designator() {}

  /// Initializes a field designator.
  Designator(const IdentifierInfo *FieldName, SourceLocation DotLoc,
             SourceLocation FieldLoc)
    : Kind(FieldDesignator) {
    new (&Field) DesignatedInitExpr::FieldDesignator;
    Field.NameOrField = reinterpret_cast<uintptr_t>(FieldName) | 0x01;
    Field.DotLoc = DotLoc;
    Field.FieldLoc = FieldLoc;
  }

  /// Initializes an array designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation RBracketLoc)
    : Kind(ArrayDesignator) {
    new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc;
    ArrayOrRange.EllipsisLoc = SourceLocation();
    ArrayOrRange.RBracketLoc = RBracketLoc;
  }

  /// Initializes a GNU array-range designator.
  Designator(unsigned Index, SourceLocation LBracketLoc,
             SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
    : Kind(ArrayRangeDesignator) {
    new (&ArrayOrRange) DesignatedInitExpr::ArrayOrRangeDesignator;
    ArrayOrRange.Index = Index;
    ArrayOrRange.LBracketLoc = LBracketLoc;
    ArrayOrRange.EllipsisLoc = EllipsisLoc;
    ArrayOrRange.RBracketLoc = RBracketLoc;
  }

  bool isFieldDesignator() const { return Kind == FieldDesignator; }
  bool isArrayDesignator() const { return Kind == ArrayDesignator; }
  bool isArrayRangeDesignator() const { return Kind == ArrayRangeDesignator; }

  IdentifierInfo *getFieldName() const;

  FieldDecl *getField() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast<void> (0));
    if (Field.NameOrField & 0x01)
      return nullptr;
    else
      return reinterpret_cast<FieldDecl *>(Field.NameOrField);
  }

  void setField(FieldDecl *FD) {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast<void> (0));
    Field.NameOrField = reinterpret_cast<uintptr_t>(FD);
  }

  SourceLocation getDotLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast<void> (0));
    return Field.DotLoc;
  }

  SourceLocation getFieldLoc() const {
    assert(Kind == FieldDesignator && "Only valid on a field designator")(static_cast<void> (0));
    return Field.FieldLoc;
  }

  SourceLocation getLBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast<void> (0))
           "Only valid on an array or array-range designator")(static_cast<void> (0));
    return ArrayOrRange.LBracketLoc;
  }

  SourceLocation getRBracketLoc() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast<void> (0))
           "Only valid on an array or array-range designator")(static_cast<void> (0));
    return ArrayOrRange.RBracketLoc;
  }

  SourceLocation getEllipsisLoc() const {
    assert(Kind == ArrayRangeDesignator &&(static_cast<void> (0))
           "Only valid on an array-range designator")(static_cast<void> (0));
    return ArrayOrRange.EllipsisLoc;
  }

  unsigned getFirstExprIndex() const {
    assert((Kind == ArrayDesignator || Kind == ArrayRangeDesignator) &&(static_cast<void> (0))
           "Only valid on an array or array-range designator")(static_cast<void> (0));
    return ArrayOrRange.Index;
  }

  SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
    if (Kind == FieldDesignator)
      return getDotLoc().isInvalid()? getFieldLoc() : getDotLoc();
    else
      return getLBracketLoc();
  }
  SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
    return Kind == FieldDesignator ? getFieldLoc() : getRBracketLoc();
  }
  SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
    return SourceRange(getBeginLoc(), getEndLoc());
  }
};

static DesignatedInitExpr *Create(const ASTContext &C,
                                  llvm::ArrayRef<Designator> Designators,
                                  ArrayRef<Expr*> IndexExprs,
                                  SourceLocation EqualOrColonLoc,
                                  bool GNUSyntax, Expr *Init);

static DesignatedInitExpr *CreateEmpty(const ASTContext &C,
                                       unsigned NumIndexExprs);

/// Returns the number of designators in this initializer.
unsigned size() const { return NumDesignators; }

// Iterator access to the designators.
llvm::MutableArrayRef<Designator> designators() {
  return {Designators, NumDesignators};
}

llvm::ArrayRef<Designator> designators() const {
  return {Designators, NumDesignators};
}

Designator *getDesignator(unsigned Idx) { return &designators()[Idx]; }
const Designator *getDesignator(unsigned Idx) const {
  return &designators()[Idx];
}

void setDesignators(const ASTContext &C, const Designator *Desigs,
                    unsigned NumDesigs);

Expr *getArrayIndex(const Designator &D) const;
Expr *getArrayRangeStart(const Designator &D) const;
Expr *getArrayRangeEnd(const Designator &D) const;

/// Retrieve the location of the '=' that precedes the
/// initializer value itself, if present.
SourceLocation getEqualOrColonLoc() const { return EqualOrColonLoc; }
void setEqualOrColonLoc(SourceLocation L) { EqualOrColonLoc = L; }

/// Whether this designated initializer should result in direct-initialization
/// of the designated subobject (eg, '{.foo{1, 2, 3}}').
bool isDirectInit() const { return EqualOrColonLoc.isInvalid(); }

/// Determines whether this designated initializer used the
/// deprecated GNU syntax for designated initializers.
bool usesGNUSyntax() const { return GNUSyntax; }
void setGNUSyntax(bool GNU) { GNUSyntax = GNU; }

/// Retrieve the initializer value.
Expr *getInit() const {
  return cast<Expr>(*const_cast<DesignatedInitExpr*>(this)->child_begin());
}

void setInit(Expr *init) {
  *child_begin() = init;
}

/// Retrieve the total number of subexpressions in this
/// designated initializer expression, including the actual
/// initialized value and any expressions that occur within array
/// and array-range designators.
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr *getSubExpr(unsigned Idx) const {
  assert(Idx < NumSubExprs && "Subscript out of range")(static_cast<void> (0));
  return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
}

void setSubExpr(unsigned Idx, Expr *E) {
  assert(Idx < NumSubExprs && "Subscript out of range")(static_cast<void> (0));
  getTrailingObjects<Stmt *>()[Idx] = E;
}

/// Replaces the designator at index @p Idx with the series
/// of designators in [First, Last).
void ExpandDesignator(const ASTContext &C, unsigned Idx,
                      const Designator *First, const Designator *Last);

SourceRange getDesignatorsSourceRange() const;

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitExprClass;
}

// Iterators
child_range children() {
  Stmt **begin = getTrailingObjects<Stmt *>();
  return child_range(begin, begin + NumSubExprs);
}
const_child_range children() const {
  Stmt * const *begin = getTrailingObjects<Stmt *>();
  return const_child_range(begin, begin + NumSubExprs);
}

friend TrailingObjects;
5314};

5316/// Represents a place-holder for an object not to be initialized by
5317/// anything.
5318///
5319/// This only makes sense when it appears as part of an updater of a
5320/// DesignatedInitUpdateExpr (see below). The base expression of a DIUE
5321/// initializes a big object, and the NoInitExpr's mark the spots within the
5322/// big object not to be overwritten by the updater.
5323///
5324/// \see DesignatedInitUpdateExpr
5325class NoInitExpr : public Expr {
5326public:
explicit NoInitExpr(QualType ty)
    : Expr(NoInitExprClass, ty, VK_PRValue, OK_Ordinary) {
  setDependence(computeDependence(this));
}

explicit NoInitExpr(EmptyShell Empty)
  : Expr(NoInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == NoInitExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
5349};

5351// In cases like:
5352//   struct Q { int a, b, c; };
5353//   Q *getQ();
5354//   void foo() {
5355//     struct A { Q q; } a = { *getQ(), .q.b = 3 };
5356//   }
5357//
5358// We will have an InitListExpr for a, with type A, and then a
5359// DesignatedInitUpdateExpr for "a.q" with type Q. The "base" for this DIUE
5360// is the call expression *getQ(); the "updater" for the DIUE is ".q.b = 3"
5361//
5362class DesignatedInitUpdateExpr : public Expr {
// BaseAndUpdaterExprs[0] is the base expression;
// BaseAndUpdaterExprs[1] is an InitListExpr overwriting part of the base.
Stmt *BaseAndUpdaterExprs[2];

5367public:
DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc,
                         Expr *baseExprs, SourceLocation rBraceLoc);

explicit DesignatedInitUpdateExpr(EmptyShell Empty)
  : Expr(DesignatedInitUpdateExprClass, Empty) { }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DesignatedInitUpdateExprClass;
}

Expr *getBase() const { return cast<Expr>(BaseAndUpdaterExprs[0]); }
void setBase(Expr *Base) { BaseAndUpdaterExprs[0] = Base; }

InitListExpr *getUpdater() const {
  return cast<InitListExpr>(BaseAndUpdaterExprs[1]);
}
void setUpdater(Expr *Updater) { BaseAndUpdaterExprs[1] = Updater; }

// Iterators
// children = the base and the updater
child_range children() {
  return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);
}
const_child_range children() const {
  return const_child_range(&BaseAndUpdaterExprs[0],
                           &BaseAndUpdaterExprs[0] + 2);
}
5398};

5400/// Represents a loop initializing the elements of an array.
5401///
5402/// The need to initialize the elements of an array occurs in a number of
5403/// contexts:
5404///
5405///  * in the implicit copy/move constructor for a class with an array member
5406///  * when a lambda-expression captures an array by value
5407///  * when a decomposition declaration decomposes an array
5408///
5409/// There are two subexpressions: a common expression (the source array)
5410/// that is evaluated once up-front, and a per-element initializer that
5411/// runs once for each array element.
5412///
5413/// Within the per-element initializer, the common expression may be referenced
5414/// via an OpaqueValueExpr, and the current index may be obtained via an
5415/// ArrayInitIndexExpr.
5416class ArrayInitLoopExpr : public Expr {
Stmt *SubExprs[2];

explicit ArrayInitLoopExpr(EmptyShell Empty)
    : Expr(ArrayInitLoopExprClass, Empty), SubExprs{} {}

5422public:
explicit ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
    : Expr(ArrayInitLoopExprClass, T, VK_PRValue, OK_Ordinary),
      SubExprs{CommonInit, ElementInit} {
  setDependence(computeDependence(this));
}

/// Get the common subexpression shared by all initializations (the source
/// array).
OpaqueValueExpr *getCommonExpr() const {
  return cast<OpaqueValueExpr>(SubExprs[0]);
}

/// Get the initializer to use for each array element.
Expr *getSubExpr() const { return cast<Expr>(SubExprs[1]); }

llvm::APInt getArraySize() const {
  return cast<ConstantArrayType>(getType()->castAsArrayTypeUnsafe())
      ->getSize();
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitLoopExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCommonExpr()->getEndLoc();
}

child_range children() {
  return child_range(SubExprs, SubExprs + 2);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + 2);
}

friend class ASTReader;
friend class ASTStmtReader;
friend class ASTStmtWriter;
5464};

5466/// Represents the index of the current element of an array being
5467/// initialized by an ArrayInitLoopExpr. This can only appear within the
5468/// subexpression of an ArrayInitLoopExpr.
5469class ArrayInitIndexExpr : public Expr {
explicit ArrayInitIndexExpr(EmptyShell Empty)
    : Expr(ArrayInitIndexExprClass, Empty) {}

5473public:
explicit ArrayInitIndexExpr(QualType T)
    : Expr(ArrayInitIndexExprClass, T, VK_PRValue, OK_Ordinary) {
  setDependence(ExprDependence::None);
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == ArrayInitIndexExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

friend class ASTReader;
friend class ASTStmtReader;
5495};

5497/// Represents an implicitly-generated value initialization of
5498/// an object of a given type.
5499///
5500/// Implicit value initializations occur within semantic initializer
5501/// list expressions (InitListExpr) as placeholders for subobject
5502/// initializations not explicitly specified by the user.
5503///
5504/// \see InitListExpr
5505class ImplicitValueInitExpr : public Expr {
5506public:
explicit ImplicitValueInitExpr(QualType ty)
    : Expr(ImplicitValueInitExprClass, ty, VK_PRValue, OK_Ordinary) {
  setDependence(computeDependence(this));
}

/// Construct an empty implicit value initialization.
explicit ImplicitValueInitExpr(EmptyShell Empty)
  : Expr(ImplicitValueInitExprClass, Empty) { }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ImplicitValueInitExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return SourceLocation(); }

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
5530};

5532class ParenListExpr final
  : public Expr,
    private llvm::TrailingObjects<ParenListExpr, Stmt *> {
friend class ASTStmtReader;
friend TrailingObjects;

/// The location of the left and right parentheses.
SourceLocation LParenLoc, RParenLoc;

/// Build a paren list.
ParenListExpr(SourceLocation LParenLoc, ArrayRef<Expr *> Exprs,
              SourceLocation RParenLoc);

/// Build an empty paren list.
ParenListExpr(EmptyShell Empty, unsigned NumExprs);

5548public:
/// Create a paren list.
static ParenListExpr *Create(const ASTContext &Ctx, SourceLocation LParenLoc,
                             ArrayRef<Expr *> Exprs,
                             SourceLocation RParenLoc);

/// Create an empty paren list.
static ParenListExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumExprs);

/// Return the number of expressions in this paren list.
unsigned getNumExprs() const { return ParenListExprBits.NumExprs; }

Expr *getExpr(unsigned Init) {
  assert(Init < getNumExprs() && "Initializer access out of range!")(static_cast<void> (0));
  return getExprs()[Init];
}

const Expr *getExpr(unsigned Init) const {
  return const_cast<ParenListExpr *>(this)->getExpr(Init);
}

Expr **getExprs() {
  return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>());
}

ArrayRef<Expr *> exprs() {
  return llvm::makeArrayRef(getExprs(), getNumExprs());
}

SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getBeginLoc() const { return getLParenLoc(); }
SourceLocation getEndLoc() const { return getRParenLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ParenListExprClass;
}

// Iterators
child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() + getNumExprs());
}
const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() + getNumExprs());
}
5595};

5597/// Represents a C11 generic selection.
5598///
5599/// A generic selection (C11 6.5.1.1) contains an unevaluated controlling
5600/// expression, followed by one or more generic associations.  Each generic
5601/// association specifies a type name and an expression, or "default" and an
5602/// expression (in which case it is known as a default generic association).
5603/// The type and value of the generic selection are identical to those of its
5604/// result expression, which is defined as the expression in the generic
5605/// association with a type name that is compatible with the type of the
5606/// controlling expression, or the expression in the default generic association
5607/// if no types are compatible.  For example:
5608///
5609/// @code
5610/// _Generic(X, double: 1, float: 2, default: 3)
5611/// @endcode
5612///
5613/// The above expression evaluates to 1 if 1.0 is substituted for X, 2 if 1.0f
5614/// or 3 if "hello".
5615///
5616/// As an extension, generic selections are allowed in C++, where the following
5617/// additional semantics apply:
5618///
5619/// Any generic selection whose controlling expression is type-dependent or
5620/// which names a dependent type in its association list is result-dependent,
5621/// which means that the choice of result expression is dependent.
5622/// Result-dependent generic associations are both type- and value-dependent.
5623class GenericSelectionExpr final
  : public Expr,
    private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
                                  TypeSourceInfo *> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The number of association expressions and the index of the result
/// expression in the case where the generic selection expression is not
/// result-dependent. The result index is equal to ResultDependentIndex
/// if and only if the generic selection expression is result-dependent.
unsigned NumAssocs, ResultIndex;
enum : unsigned {
  ResultDependentIndex = std::numeric_limits<unsigned>::max(),
  ControllingIndex = 0,
  AssocExprStartIndex = 1
};

/// The location of the "default" and of the right parenthesis.
SourceLocation DefaultLoc, RParenLoc;

// GenericSelectionExpr is followed by several trailing objects.
// They are (in order):
//
// * A single Stmt * for the controlling expression.
// * An array of getNumAssocs() Stmt * for the association expressions.
// * An array of getNumAssocs() TypeSourceInfo *, one for each of the
//   association expressions.
unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
  // Add one to account for the controlling expression; the remainder
  // are the associated expressions.
  return 1 + getNumAssocs();
}

unsigned numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
  return getNumAssocs();
}

template <bool Const> class AssociationIteratorTy;
/// Bundle together an association expression and its TypeSourceInfo.
/// The Const template parameter is for the const and non-const versions
/// of AssociationTy.
template <bool Const> class AssociationTy {
  friend class GenericSelectionExpr;
  template <bool OtherConst> friend class AssociationIteratorTy;
  using ExprPtrTy = std::conditional_t<Const, const Expr *, Expr *>;
  using TSIPtrTy =
      std::conditional_t<Const, const TypeSourceInfo *, TypeSourceInfo *>;
  ExprPtrTy E;
  TSIPtrTy TSI;
  bool Selected;
  AssociationTy(ExprPtrTy E, TSIPtrTy TSI, bool Selected)
      : E(E), TSI(TSI), Selected(Selected) {}

public:
  ExprPtrTy getAssociationExpr() const { return E; }
  TSIPtrTy getTypeSourceInfo() const { return TSI; }
  QualType getType() const { return TSI ? TSI->getType() : QualType(); }
  bool isSelected() const { return Selected; }
  AssociationTy *operator->() { return this; }
  const AssociationTy *operator->() const { return this; }
}; // class AssociationTy

/// Iterator over const and non-const Association objects. The Association
/// objects are created on the fly when the iterator is dereferenced.
/// This abstract over how exactly the association expressions and the
/// corresponding TypeSourceInfo * are stored.
template <bool Const>
class AssociationIteratorTy
    : public llvm::iterator_facade_base<
          AssociationIteratorTy<Const>, std::input_iterator_tag,
          AssociationTy<Const>, std::ptrdiff_t, AssociationTy<Const>,
          AssociationTy<Const>> {
  friend class GenericSelectionExpr;
  // FIXME: This iterator could conceptually be a random access iterator, and
  // it would be nice if we could strengthen the iterator category someday.
  // However this iterator does not satisfy two requirements of forward
  // iterators:
  // a) reference = T& or reference = const T&
  // b) If It1 and It2 are both dereferenceable, then It1 == It2 if and only
  //    if *It1 and *It2 are bound to the same objects.
  // An alternative design approach was discussed during review;
  // store an Association object inside the iterator, and return a reference
  // to it when dereferenced. This idea was discarded beacuse of nasty
  // lifetime issues:
  //    AssociationIterator It = ...;
  //    const Association &Assoc = *It++; // Oops, Assoc is dangling.
  using BaseTy = typename AssociationIteratorTy::iterator_facade_base;
  using StmtPtrPtrTy =
      std::conditional_t<Const, const Stmt *const *, Stmt **>;
  using TSIPtrPtrTy = std::conditional_t<Const, const TypeSourceInfo *const *,
                                         TypeSourceInfo **>;
  StmtPtrPtrTy E; // = nullptr; FIXME: Once support for gcc 4.8 is dropped.
  TSIPtrPtrTy TSI; // Kept in sync with E.
  unsigned Offset = 0, SelectedOffset = 0;
  AssociationIteratorTy(StmtPtrPtrTy E, TSIPtrPtrTy TSI, unsigned Offset,
                        unsigned SelectedOffset)
      : E(E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {}

public:
  AssociationIteratorTy() : E(nullptr), TSI(nullptr) {}
  typename BaseTy::reference operator*() const {
    return AssociationTy<Const>(cast<Expr>(*E), *TSI,
                                Offset == SelectedOffset);
  }
  typename BaseTy::pointer operator->() const { return **this; }
  using BaseTy::operator++;
  AssociationIteratorTy &operator++() {
    ++E;
    ++TSI;
    ++Offset;
    return *this;
  }
  bool operator==(AssociationIteratorTy Other) const { return E == Other.E; }
}; // class AssociationIterator

/// Build a non-result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
                     Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo *> AssocTypes,
                     ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
                     SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack,
                     unsigned ResultIndex);

/// Build a result-dependent generic selection expression.
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc,
                     Expr *ControllingExpr,
                     ArrayRef<TypeSourceInfo *> AssocTypes,
                     ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
                     SourceLocation RParenLoc,
                     bool ContainsUnexpandedParameterPack);

/// Build an empty generic selection expression for deserialization.
explicit GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs);

5760public:
/// Create a non-result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
       Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
       ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
       SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack,
       unsigned ResultIndex);

/// Create a result-dependent generic selection expression.
static GenericSelectionExpr *
Create(const ASTContext &Context, SourceLocation GenericLoc,
       Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
       ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
       SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack);

/// Create an empty generic selection expression for deserialization.
static GenericSelectionExpr *CreateEmpty(const ASTContext &Context,
                                         unsigned NumAssocs);

using Association = AssociationTy<false>;
using ConstAssociation = AssociationTy<true>;
using AssociationIterator = AssociationIteratorTy<false>;
using ConstAssociationIterator = AssociationIteratorTy<true>;
using association_range = llvm::iterator_range<AssociationIterator>;
using const_association_range =
    llvm::iterator_range<ConstAssociationIterator>;

/// The number of association expressions.
unsigned getNumAssocs() const { return NumAssocs; }

/// The zero-based index of the result expression's generic association in
/// the generic selection's association list.  Defined only if the
/// generic selection is not result-dependent.
unsigned getResultIndex() const {
  assert(!isResultDependent() &&(static_cast<void> (0))
         "Generic selection is result-dependent but getResultIndex called!")(static_cast<void> (0));
  return ResultIndex;
}

/// Whether this generic selection is result-dependent.
bool isResultDependent() const { return ResultIndex == ResultDependentIndex; }

/// Return the controlling expression of this generic selection expression.
Expr *getControllingExpr() {
  return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}
const Expr *getControllingExpr() const {
  return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
}

/// Return the result expression of this controlling expression. Defined if
/// and only if the generic selection expression is not result-dependent.
Expr *getResultExpr() {
  return cast<Expr>(
      getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}
const Expr *getResultExpr() const {
  return cast<Expr>(
      getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
}

ArrayRef<Expr *> getAssocExprs() const {
  return {reinterpret_cast<Expr *const *>(getTrailingObjects<Stmt *>() +
                                          AssocExprStartIndex),
          NumAssocs};
}
ArrayRef<TypeSourceInfo *> getAssocTypeSourceInfos() const {
  return {getTrailingObjects<TypeSourceInfo *>(), NumAssocs};
}

/// Return the Ith association expression with its TypeSourceInfo,
/// bundled together in GenericSelectionExpr::(Const)Association.
Association getAssociation(unsigned I) {
  assert(I < getNumAssocs() &&(static_cast<void> (0))
         "Out-of-range index in GenericSelectionExpr::getAssociation!")(static_cast<void> (0));
  return Association(
      cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
      getTrailingObjects<TypeSourceInfo *>()[I],
      !isResultDependent() && (getResultIndex() == I));
}
ConstAssociation getAssociation(unsigned I) const {
  assert(I < getNumAssocs() &&(static_cast<void> (0))
         "Out-of-range index in GenericSelectionExpr::getAssociation!")(static_cast<void> (0));
  return ConstAssociation(
      cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
      getTrailingObjects<TypeSourceInfo *>()[I],
      !isResultDependent() && (getResultIndex() == I));
}

association_range associations() {
  AssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                AssocExprStartIndex,
                            getTrailingObjects<TypeSourceInfo *>(),
                            /*Offset=*/0, ResultIndex);
  AssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                          /*Offset=*/NumAssocs, ResultIndex);
  return llvm::make_range(Begin, End);
}

const_association_range associations() const {
  ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
                                     AssocExprStartIndex,
                                 getTrailingObjects<TypeSourceInfo *>(),
                                 /*Offset=*/0, ResultIndex);
  ConstAssociationIterator End(Begin.E + NumAssocs, Begin.TSI + NumAssocs,
                               /*Offset=*/NumAssocs, ResultIndex);
  return llvm::make_range(Begin, End);
}

SourceLocation getGenericLoc() const {
  return GenericSelectionExprBits.GenericLoc;
}
SourceLocation getDefaultLoc() const { return DefaultLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getBeginLoc() const { return getGenericLoc(); }
SourceLocation getEndLoc() const { return getRParenLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == GenericSelectionExprClass;
}

child_range children() {
  return child_range(getTrailingObjects<Stmt *>(),
                     getTrailingObjects<Stmt *>() +
                         numTrailingObjects(OverloadToken<Stmt *>()));
}
const_child_range children() const {
  return const_child_range(getTrailingObjects<Stmt *>(),
                           getTrailingObjects<Stmt *>() +
                               numTrailingObjects(OverloadToken<Stmt *>()));
}
5892};

5894//===----------------------------------------------------------------------===//
5895// Clang Extensions
5896//===----------------------------------------------------------------------===//

5898/// ExtVectorElementExpr - This represents access to specific elements of a
5899/// vector, and may occur on the left hand side or right hand side.  For example
5900/// the following is legal:  "V.xy = V.zw" if V is a 4 element extended vector.
5901///
5902/// Note that the base may have either vector or pointer to vector type, just
5903/// like a struct field reference.
5904///
5905class ExtVectorElementExpr : public Expr {
Stmt *Base;
IdentifierInfo *Accessor;
SourceLocation AccessorLoc;
5909public:
ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base,
                     IdentifierInfo &accessor, SourceLocation loc)
    : Expr(ExtVectorElementExprClass, ty, VK,
           (VK == VK_PRValue ? OK_Ordinary : OK_VectorComponent)),
      Base(base), Accessor(&accessor), AccessorLoc(loc) {
  setDependence(computeDependence(this));
}

/// Build an empty vector element expression.
explicit ExtVectorElementExpr(EmptyShell Empty)
  : Expr(ExtVectorElementExprClass, Empty) { }

const Expr *getBase() const { return cast<Expr>(Base); }
Expr *getBase() { return cast<Expr>(Base); }
void setBase(Expr *E) { Base = E; }

IdentifierInfo &getAccessor() const { return *Accessor; }
void setAccessor(IdentifierInfo *II) { Accessor = II; }

SourceLocation getAccessorLoc() const { return AccessorLoc; }
void setAccessorLoc(SourceLocation L) { AccessorLoc = L; }

/// getNumElements - Get the number of components being selected.
unsigned getNumElements() const;

/// containsDuplicateElements - Return true if any element access is
/// repeated.
bool containsDuplicateElements() const;

/// getEncodedElementAccess - Encode the elements accessed into an llvm
/// aggregate Constant of ConstantInt(s).
void getEncodedElementAccess(SmallVectorImpl<uint32_t> &Elts) const;

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return AccessorLoc; }

/// isArrow - Return true if the base expression is a pointer to vector,
/// return false if the base expression is a vector.
bool isArrow() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExtVectorElementExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base+1); }
const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
5961};

5963/// BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
5964/// ^{ statement-body }   or   ^(int arg1, float arg2){ statement-body }
5965class BlockExpr : public Expr {
5966protected:
BlockDecl *TheBlock;
5968public:
BlockExpr(BlockDecl *BD, QualType ty)
    : Expr(BlockExprClass, ty, VK_PRValue, OK_Ordinary), TheBlock(BD) {
  setDependence(computeDependence(this));
}

/// Build an empty block expression.
explicit BlockExpr(EmptyShell Empty) : Expr(BlockExprClass, Empty) { }

const BlockDecl *getBlockDecl() const { return TheBlock; }
BlockDecl *getBlockDecl() { return TheBlock; }
void setBlockDecl(BlockDecl *BD) { TheBlock = BD; }

// Convenience functions for probing the underlying BlockDecl.
SourceLocation getCaretLocation() const;
const Stmt *getBody() const;
Stmt *getBody();

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getCaretLocation();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBody()->getEndLoc();
}

/// getFunctionType - Return the underlying function type for this block.
const FunctionProtoType *getFunctionType() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == BlockExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
6007};

6009/// Copy initialization expr of a __block variable and a boolean flag that
6010/// indicates whether the expression can throw.
6011struct BlockVarCopyInit {
BlockVarCopyInit() = default;
BlockVarCopyInit(Expr *CopyExpr, bool CanThrow)
    : ExprAndFlag(CopyExpr, CanThrow) {}
void setExprAndFlag(Expr *CopyExpr, bool CanThrow) {
  ExprAndFlag.setPointerAndInt(CopyExpr, CanThrow);
}
Expr *getCopyExpr() const { return ExprAndFlag.getPointer(); }
bool canThrow() const { return ExprAndFlag.getInt(); }
llvm::PointerIntPair<Expr *, 1, bool> ExprAndFlag;
6021};

6023/// AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2]
6024/// This AST node provides support for reinterpreting a type to another
6025/// type of the same size.
6026class AsTypeExpr : public Expr {
6027private:
Stmt *SrcExpr;
SourceLocation BuiltinLoc, RParenLoc;

friend class ASTReader;
friend class ASTStmtReader;
explicit AsTypeExpr(EmptyShell Empty) : Expr(AsTypeExprClass, Empty) {}

6035public:
AsTypeExpr(Expr *SrcExpr, QualType DstType, ExprValueKind VK,
           ExprObjectKind OK, SourceLocation BuiltinLoc,
           SourceLocation RParenLoc)
    : Expr(AsTypeExprClass, DstType, VK, OK), SrcExpr(SrcExpr),
      BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {
  setDependence(computeDependence(this));
}

/// getSrcExpr - Return the Expr to be converted.
Expr *getSrcExpr() const { return cast<Expr>(SrcExpr); }

/// getBuiltinLoc - Return the location of the __builtin_astype token.
SourceLocation getBuiltinLoc() const { return BuiltinLoc; }

/// getRParenLoc - Return the location of final right parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AsTypeExprClass;
}

// Iterators
child_range children() { return child_range(&SrcExpr, &SrcExpr+1); }
const_child_range children() const {
  return const_child_range(&SrcExpr, &SrcExpr + 1);
}
6065};

6067/// PseudoObjectExpr - An expression which accesses a pseudo-object
6068/// l-value.  A pseudo-object is an abstract object, accesses to which
6069/// are translated to calls.  The pseudo-object expression has a
6070/// syntactic form, which shows how the expression was actually
6071/// written in the source code, and a semantic form, which is a series
6072/// of expressions to be executed in order which detail how the
6073/// operation is actually evaluated.  Optionally, one of the semantic
6074/// forms may also provide a result value for the expression.
6075///
6076/// If any of the semantic-form expressions is an OpaqueValueExpr,
6077/// that OVE is required to have a source expression, and it is bound
6078/// to the result of that source expression.  Such OVEs may appear
6079/// only in subsequent semantic-form expressions and as
6080/// sub-expressions of the syntactic form.
6081///
6082/// PseudoObjectExpr should be used only when an operation can be
6083/// usefully described in terms of fairly simple rewrite rules on
6084/// objects and functions that are meant to be used by end-developers.
6085/// For example, under the Itanium ABI, dynamic casts are implemented
6086/// as a call to a runtime function called __dynamic_cast; using this
6087/// class to describe that would be inappropriate because that call is
6088/// not really part of the user-visible semantics, and instead the
6089/// cast is properly reflected in the AST and IR-generation has been
6090/// taught to generate the call as necessary.  In contrast, an
6091/// Objective-C property access is semantically defined to be
6092/// equivalent to a particular message send, and this is very much
6093/// part of the user model.  The name of this class encourages this
6094/// modelling design.
6095class PseudoObjectExpr final
  : public Expr,
    private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
// PseudoObjectExprBits.NumSubExprs - The number of sub-expressions.
// Always at least two, because the first sub-expression is the
// syntactic form.

// PseudoObjectExprBits.ResultIndex - The index of the
// sub-expression holding the result.  0 means the result is void,
// which is unambiguous because it's the index of the syntactic
// form.  Note that this is therefore 1 higher than the value passed
// in to Create, which is an index within the semantic forms.
// Note also that ASTStmtWriter assumes this encoding.

Expr **getSubExprsBuffer() { return getTrailingObjects<Expr *>(); }
const Expr * const *getSubExprsBuffer() const {
  return getTrailingObjects<Expr *>();
}

PseudoObjectExpr(QualType type, ExprValueKind VK,
                 Expr *syntactic, ArrayRef<Expr*> semantic,
                 unsigned resultIndex);

PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs);

unsigned getNumSubExprs() const {
  return PseudoObjectExprBits.NumSubExprs;
}

6124public:
/// NoResult - A value for the result index indicating that there is
/// no semantic result.
enum : unsigned { NoResult = ~0U };

static PseudoObjectExpr *Create(const ASTContext &Context, Expr *syntactic,
                                ArrayRef<Expr*> semantic,
                                unsigned resultIndex);

static PseudoObjectExpr *Create(const ASTContext &Context, EmptyShell shell,
                                unsigned numSemanticExprs);

/// Return the syntactic form of this expression, i.e. the
/// expression it actually looks like.  Likely to be expressed in
/// terms of OpaqueValueExprs bound in the semantic form.
Expr *getSyntacticForm() { return getSubExprsBuffer()[0]; }
const Expr *getSyntacticForm() const { return getSubExprsBuffer()[0]; }

/// Return the index of the result-bearing expression into the semantics
/// expressions, or PseudoObjectExpr::NoResult if there is none.
unsigned getResultExprIndex() const {
  if (PseudoObjectExprBits.ResultIndex == 0) return NoResult;
  return PseudoObjectExprBits.ResultIndex - 1;
}

/// Return the result-bearing expression, or null if there is none.
Expr *getResultExpr() {
  if (PseudoObjectExprBits.ResultIndex == 0)
    return nullptr;
  return getSubExprsBuffer()[PseudoObjectExprBits.ResultIndex];
}
const Expr *getResultExpr() const {
  return const_cast<PseudoObjectExpr*>(this)->getResultExpr();
}

unsigned getNumSemanticExprs() const { return getNumSubExprs() - 1; }

typedef Expr * const *semantics_iterator;
typedef const Expr * const *const_semantics_iterator;
semantics_iterator semantics_begin() {
  return getSubExprsBuffer() + 1;
}
const_semantics_iterator semantics_begin() const {
  return getSubExprsBuffer() + 1;
}
semantics_iterator semantics_end() {
  return getSubExprsBuffer() + getNumSubExprs();
}
const_semantics_iterator semantics_end() const {
  return getSubExprsBuffer() + getNumSubExprs();
}

llvm::iterator_range<semantics_iterator> semantics() {
  return llvm::make_range(semantics_begin(), semantics_end());
}
llvm::iterator_range<const_semantics_iterator> semantics() const {
  return llvm::make_range(semantics_begin(), semantics_end());
}

Expr *getSemanticExpr(unsigned index) {
  assert(index + 1 < getNumSubExprs())(static_cast<void> (0));
  return getSubExprsBuffer()[index + 1];
}
const Expr *getSemanticExpr(unsigned index) const {
  return const_cast<PseudoObjectExpr*>(this)->getSemanticExpr(index);
}

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getExprLoc();
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getSyntacticForm()->getEndLoc();
}

child_range children() {
  const_child_range CCR =
      const_cast<const PseudoObjectExpr *>(this)->children();
  return child_range(cast_away_const(CCR.begin()),
                     cast_away_const(CCR.end()));
}
const_child_range children() const {
  Stmt *const *cs = const_cast<Stmt *const *>(
      reinterpret_cast<const Stmt *const *>(getSubExprsBuffer()));
  return const_child_range(cs, cs + getNumSubExprs());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == PseudoObjectExprClass;
}

friend TrailingObjects;
friend class ASTStmtReader;
6220};

6222/// AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*,
6223/// __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the
6224/// similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>,
6225/// and corresponding __opencl_atomic_* for OpenCL 2.0.
6226/// All of these instructions take one primary pointer, at least one memory
6227/// order. The instructions for which getScopeModel returns non-null value
6228/// take one synch scope.
6229class AtomicExpr : public Expr {
6230public:
enum AtomicOp {
6232#define BUILTIN(ID, TYPE, ATTRS)
6233#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
6234#include "clang/Basic/Builtins.def"
  // Avoid trailing comma
  BI_First = 0
};

6239private:
/// Location of sub-expressions.
/// The location of Scope sub-expression is NumSubExprs - 1, which is
/// not fixed, therefore is not defined in enum.
enum { PTR, ORDER, VAL1, ORDER_FAIL, VAL2, WEAK, END_EXPR };
Stmt *SubExprs[END_EXPR + 1];
unsigned NumSubExprs;
SourceLocation BuiltinLoc, RParenLoc;
AtomicOp Op;

friend class ASTStmtReader;
6250public:
AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, QualType t,
           AtomicOp op, SourceLocation RP);

/// Determine the number of arguments the specified atomic builtin
/// should have.
static unsigned getNumSubExprs(AtomicOp Op);

/// Build an empty AtomicExpr.
explicit AtomicExpr(EmptyShell Empty) : Expr(AtomicExprClass, Empty) { }

Expr *getPtr() const {
  return cast<Expr>(SubExprs[PTR]);
}
Expr *getOrder() const {
  return cast<Expr>(SubExprs[ORDER]);
}
Expr *getScope() const {
  assert(getScopeModel() && "No scope")(static_cast<void> (0));
  return cast<Expr>(SubExprs[NumSubExprs - 1]);
}
Expr *getVal1() const {
  if (Op == AO__c11_atomic_init || Op == AO__opencl_atomic_init)
    return cast<Expr>(SubExprs[ORDER]);
  assert(NumSubExprs > VAL1)(static_cast<void> (0));
  return cast<Expr>(SubExprs[VAL1]);
}
Expr *getOrderFail() const {
  assert(NumSubExprs > ORDER_FAIL)(static_cast<void> (0));
  return cast<Expr>(SubExprs[ORDER_FAIL]);
}
Expr *getVal2() const {
  if (Op == AO__atomic_exchange)
    return cast<Expr>(SubExprs[ORDER_FAIL]);
  assert(NumSubExprs > VAL2)(static_cast<void> (0));
  return cast<Expr>(SubExprs[VAL2]);
}
Expr *getWeak() const {
  assert(NumSubExprs > WEAK)(static_cast<void> (0));
  return cast<Expr>(SubExprs[WEAK]);
}
QualType getValueType() const;

AtomicOp getOp() const { return Op; }
unsigned getNumSubExprs() const { return NumSubExprs; }

Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
const Expr * const *getSubExprs() const {
  return reinterpret_cast<Expr * const *>(SubExprs);
}

bool isVolatile() const {
  return getPtr()->getType()->getPointeeType().isVolatileQualified();
}

bool isCmpXChg() const {
  return getOp() == AO__c11_atomic_compare_exchange_strong ||
         getOp() == AO__c11_atomic_compare_exchange_weak ||
         getOp() == AO__opencl_atomic_compare_exchange_strong ||
         getOp() == AO__opencl_atomic_compare_exchange_weak ||
         getOp() == AO__atomic_compare_exchange ||
         getOp() == AO__atomic_compare_exchange_n;
}

bool isOpenCL() const {
  return getOp() >= AO__opencl_atomic_init &&
         getOp() <= AO__opencl_atomic_fetch_max;
}

SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return BuiltinLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == AtomicExprClass;
}

// Iterators
child_range children() {
  return child_range(SubExprs, SubExprs+NumSubExprs);
}
const_child_range children() const {
  return const_child_range(SubExprs, SubExprs + NumSubExprs);
}

/// Get atomic scope model for the atomic op code.
/// \return empty atomic scope model if the atomic op code does not have
///   scope operand.
static std::unique_ptr<AtomicScopeModel> getScopeModel(AtomicOp Op) {
  auto Kind =
      (Op >= AO__opencl_atomic_load && Op <= AO__opencl_atomic_fetch_max)
          ? AtomicScopeModelKind::OpenCL
          : AtomicScopeModelKind::None;
  return AtomicScopeModel::create(Kind);
}

/// Get atomic scope model.
/// \return empty atomic scope model if this atomic expression does not have
///   scope operand.
std::unique_ptr<AtomicScopeModel> getScopeModel() const {
  return getScopeModel(getOp());
}
6354};

6356/// TypoExpr - Internal placeholder for expressions where typo correction
6357/// still needs to be performed and/or an error diagnostic emitted.
6358class TypoExpr : public Expr {
// The location for the typo name.
SourceLocation TypoLoc;

6362public:
TypoExpr(QualType T, SourceLocation TypoLoc)
    : Expr(TypoExprClass, T, VK_LValue, OK_Ordinary), TypoLoc(TypoLoc) {
  assert(T->isDependentType() && "TypoExpr given a non-dependent type")(static_cast<void> (0));
  setDependence(ExprDependence::TypeValueInstantiation |
                ExprDependence::Error);
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}
const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return TypoLoc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return TypoLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == TypoExprClass;
}

6384};

6386/// Frontend produces RecoveryExprs on semantic errors that prevent creating
6387/// other well-formed expressions. E.g. when type-checking of a binary operator
6388/// fails, we cannot produce a BinaryOperator expression. Instead, we can choose
6389/// to produce a recovery expression storing left and right operands.
6390///
6391/// RecoveryExpr does not have any semantic meaning in C++, it is only useful to
6392/// preserve expressions in AST that would otherwise be dropped. It captures
6393/// subexpressions of some expression that we could not construct and source
6394/// range covered by the expression.
6395///
6396/// By default, RecoveryExpr uses dependence-bits to take advantage of existing
6397/// machinery to deal with dependent code in C++, e.g. RecoveryExpr is preserved
6398/// in `decltype(<broken-expr>)` as part of the `DependentDecltypeType`. In
6399/// addition to that, clang does not report most errors on dependent
6400/// expressions, so we get rid of bogus errors for free. However, note that
6401/// unlike other dependent expressions, RecoveryExpr can be produced in
6402/// non-template contexts.
6403///
6404/// We will preserve the type in RecoveryExpr when the type is known, e.g.
6405/// preserving the return type for a broken non-overloaded function call, a
6406/// overloaded call where all candidates have the same return type. In this
6407/// case, the expression is not type-dependent (unless the known type is itself
6408/// dependent)
6409///
6410/// One can also reliably suppress all bogus errors on expressions containing
6411/// recovery expressions by examining results of Expr::containsErrors().
6412class RecoveryExpr final : public Expr,
                         private llvm::TrailingObjects<RecoveryExpr, Expr *> {
6414public:
static RecoveryExpr *Create(ASTContext &Ctx, QualType T,
                            SourceLocation BeginLoc, SourceLocation EndLoc,
                            ArrayRef<Expr *> SubExprs);
static RecoveryExpr *CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs);

ArrayRef<Expr *> subExpressions() {
  auto *B = getTrailingObjects<Expr *>();
  return llvm::makeArrayRef(B, B + NumExprs);
}

ArrayRef<const Expr *> subExpressions() const {
  return const_cast<RecoveryExpr *>(this)->subExpressions();
}

child_range children() {
  Stmt **B = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
  return child_range(B, B + NumExprs);
}

SourceLocation getBeginLoc() const { return BeginLoc; }
SourceLocation getEndLoc() const { return EndLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == RecoveryExprClass;
}

6441private:
RecoveryExpr(ASTContext &Ctx, QualType T, SourceLocation BeginLoc,
             SourceLocation EndLoc, ArrayRef<Expr *> SubExprs);
RecoveryExpr(EmptyShell Empty, unsigned NumSubExprs)
    : Expr(RecoveryExprClass, Empty), NumExprs(NumSubExprs) {}

size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumExprs; }

SourceLocation BeginLoc, EndLoc;
unsigned NumExprs;
friend TrailingObjects;
friend class ASTStmtReader;
friend class ASTStmtWriter;
6454};

6456} // end namespace clang

6458#endif // LLVM_CLANG_AST_EXPR_H