/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaExpr.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaExpr.cpp
Warning:	line 7418, column 38 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include/clang/Sema -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangSema/../include -I /usr/src/gnu/usr.bin/clang/libclangSema/obj -I /usr/src/gnu/usr.bin/clang/libclangSema/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangSema/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/clang/lib/Sema/SemaExpr.cpp

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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())((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")((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")((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?")((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")((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")((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() &&((void)0)
         "Unexpected typesize for LongLongTy")((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())((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())((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")((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)((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() &&((void)0)
       "The remaining types must be floating point types.")((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)((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.")((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()) &&((void)0)
       "Expected at least one of the operands to be a fixed point type")((void)0);
assert((LHSTy->isFixedPointOrIntegerType() ||((void)0)
        RHSTy->isFixedPointOrIntegerType()) &&((void)0)
       "Special fixed point arithmetic operation conversions are only "((void)0)
       "applied to ints or other fixed point types")((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())((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())((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")((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!")((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())((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 &&((void)0)
         "Diagnosing an empty lookup with explicit template args!")((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) &&((void)0)
       "cannot be direct & operand and have a trailing lparen")((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) &&((void)0)
         "Typo correction callback misconfigured")((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() &&((void)0)
         "DiagnoseEmptyLookup returned false but added no results")((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)((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>() &&((void)0)
           "There should only be one declaration found.")((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() &&((void)0)
       "should not reference ivar from this context")((void)0);

ObjCInterfaceDecl *IFace = CurMethod->getClassInterface();
assert(IFace && "should not reference ivar from this context")((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")((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")((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")((void)0);
assert(!isa<FunctionTemplateDecl>(D) &&((void)0)
       "Cannot refer unambiguously to a function template")((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.
3262#define ABSTRACT_DECL(kind)
3263#define VALUE(type, base)
3264#define DECL(type, base) \
  case Decl::type:
3266#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 &&((void)0)
           "building reference to field in C?")((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);
}
3453}

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

3467ExprResult 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);
3518}

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

3527ExprResult 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);
3540}

3542ExprResult 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);
3557}

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

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

3622static 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);
3652}

3654bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {
assert(E && "Invalid expression")((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;
3680}

3682ExprResult 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().OpenCLVersion >= 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() &&((void)0)
           "long long is not intmax_t?")((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 &&((void)0)
             "size_t literals can't be Microsoft literals")((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;
4052}

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

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

4081static 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;
4109}

4111static 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;
4125}

4127/// Check whether E is a pointer from a decayed array type (the decayed
4128/// pointer type is equal to T) and emit a warning if it is.
4129static 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();
4143}

4145/// Check the constraints on expression operands to unary type expression
4146/// and type traits.
4147///
4148/// Completes any types necessary and validates the constraints on the operand
4149/// expression. The logic mostly mirrors the type-based overload, but may modify
4150/// the expression as it completes the type for that expression through template
4151/// instantiation, etc.
4152bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
                                          UnaryExprOrTypeTrait ExprKind) {
QualType ExprTy = E->getType();
assert(!ExprTy->isReferenceType())((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())((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;
4242}

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

4308static 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);
4362}

4364bool 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);
4372}

4374static void captureVariablyModifiedType(ASTContext &Context, QualType T,
                                      CapturingScopeInfo *CSI) {
assert(T->isVariablyModifiedType())((void)0);
assert(CSI != nullptr)((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()) {
4383#define TYPE(Class, Base)
4384#define ABSTRACT_TYPE(Class, Base)
4385#define NON_CANONICAL_TYPE(Class, Base)
4386#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4387#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4388#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());
4477}

4479/// Build a sizeof or alignof expression given a type operand.
4480ExprResult
4481Sema::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());
4521}

4523/// Build a sizeof or alignof expression given an expression
4524/// operand.
4525ExprResult
4526Sema::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());
4564}

4566/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
4567/// expr and the same for @c alignof and @c __alignof
4568/// Note that the ArgRange is invalid if isType is false.
4569ExprResult
4570Sema::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;
4585}

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



4623ExprResult
4624Sema::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);
4639}

4641/// Diagnose if arithmetic on the given ObjC pointer is illegal.
4642///
4643/// \return true on error
4644static bool checkArithmeticOnObjCPointer(Sema &S,
                                       SourceLocation opLoc,
                                       Expr *op) {
assert(op->getType()->isObjCObjectPointerType())((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;
4656}

4658static 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);
4663}

4665ExprResult
4666Sema::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() &&((void)0)
         "base has to be an incomplete matrix subscript")((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;
4797}

4799ExprResult 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);
4805}

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

4873void 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);
4884}

4886void 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);
}
4919}

4921ExprResult 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);
5107}

5109ExprResult 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);
5182}

5184ExprResult 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.")((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);
5468}

5470ExprResult
5471Sema::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 ||((void)0)
       !ResultType.isCForbiddenLValueType())((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);
5663}

5665bool 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?")((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() &&((void)0)
         "default argument expression has capturing blocks?")((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;
5717}

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

5727Sema::VariadicCallType
5728Sema::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;
5744}

5746namespace {
5747class FunctionCallCCC final : public FunctionCallFilterCCC {
5748public:
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);
}

5767private:
const IdentifierInfo *const FunctionName;
5769};
5770}

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

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

5934bool 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")((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;
6036}

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

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

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

6112/// Is the given type a placeholder that we need to lower out
6113/// immediately during argument processing?
6114static 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.
6121#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
6123#include "clang/Basic/OpenCLImageTypes.def"
6124#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
6126#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.
6129#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
6131#include "clang/Basic/AArch64SVEACLETypes.def"
6132#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
6134#include "clang/Basic/PPCTypes.def"
6135#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
6136#include "clang/Basic/RISCVVTypes.def"
6137#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
6138#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
6139#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();
6172}

6174/// Check an argument list for placeholders that we won't try to
6175/// handle later.
6176static 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;
6188}

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

6276static 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;
}
6301}

6303static 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")((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);
6342}

6344static void
6345tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
  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);
}
6382}

6384ExprResult 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;
6410}

6412/// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
6413/// This provides the location of the left/right parens and a list of comma
6414/// locations.
6415ExprResult 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 (Context.isDependenceAllowed() &&
    (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs))) {
  assert(!getLangOpts().CPlusPlus)((void)0);
  assert((Fn->containsErrors() ||((void)0)
          llvm::any_of(ArgExprs,((void)0)
                       [](clang::Expr *E) { return E->containsErrors(); })) &&((void)0)
         "should only occur in error-recovery path.")((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);
6565}

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

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

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

assert(!Call.isInvalid() && "Call to builtin cannot fail!")((void)0);
return Call.get();
6588}

6590/// Parse a __builtin_astype expression.
6591///
6592/// __builtin_astype( value, dst type )
6593///
6594ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                               SourceLocation BuiltinLoc,
                               SourceLocation RParenLoc) {
QualType DstTy = GetTypeFromParser(ParsedDestTy);
return BuildAsTypeExpr(E, DstTy, BuiltinLoc, RParenLoc);
6599}

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

6616/// ActOnConvertVectorExpr - create a new convert-vector expression from the
6617/// provided arguments.
6618///
6619/// __builtin_convertvector( value, dst type )
6620///
6621ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
                                      SourceLocation BuiltinLoc,
                                      SourceLocation RParenLoc) {
TypeSourceInfo *TInfo;
GetTypeFromParser(ParsedDestTy, &TInfo);
return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
6627}

6629/// BuildResolvedCallExpr - Build a call to a resolved expression,
6630/// i.e. an expression not of \p OverloadTy.  The expression should
6631/// unary-convert to an expression of function-pointer or
6632/// block-pointer type.
6633///
6634/// \param NDecl the declaration being called, if available
6635ExprResult 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 &&((void)0)
         "CUDAKernelCallExpr should not use ADL")((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!")((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);
6908}

6910ExprResult
6911Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, ParsedType Ty,
                         SourceLocation RParenLoc, Expr *InitExpr) {
assert(Ty && "ActOnCompoundLiteral(): missing type")((void)0);
assert(InitExpr && "ActOnCompoundLiteral(): missing expression")((void)0);

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

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

6924ExprResult
6925Sema::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);
7034}

7036ExprResult
7037Sema::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);
7102}

7104ExprResult
7105Sema::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;
7128}

7130/// Do an explicit extend of the given block pointer if we're in ARC.
7131void Sema::maybeExtendBlockObject(ExprResult &E) {
assert(E.get()->getType()->isBlockPointerType())((void)0);
assert(E.get()->isPRValue())((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);
7142}

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

7159/// Prepares for a scalar cast, performing all the necessary stages
7160/// except the final cast and returning the kind required.
7161CastKind 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();
7366}

7368static bool breakDownVectorType(QualType type, uint64_t &len,
                              QualType &eltType) {
// Vectors are simple.
if (const VectorType *vecType = type->getAs<VectorType>()) {
  len = vecType->getNumElements();
  eltType = vecType->getElementType();
  assert(eltType->isScalarType())((void)0);
  return true;
}

// We allow lax conversion to and from non-vector types, but only if
// they're real types (i.e. non-complex, non-pointer scalar types).
if (!type->isRealType()) return false;

len = 1;
eltType = type;
return true;
7385}

7387/// Are the two types SVE-bitcast-compatible types? I.e. is bitcasting from the
7388/// first SVE type (e.g. an SVE VLAT) to the second type (e.g. an SVE VLST)
7389/// allowed?
7390///
7391/// This will also return false if the two given types do not make sense from
7392/// the perspective of SVE bitcasts.
7393bool Sema::isValidSveBitcast(QualType srcTy, QualType destTy) {
assert(srcTy->isVectorType() || destTy->isVectorType())((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);
7407}

7409/// Are the two types matrix types and do they have the same dimensions i.e.
7410/// do they have the same number of rows and the same number of columns?
7411bool Sema::areMatrixTypesOfTheSameDimension(QualType srcTy, QualType destTy) {
if (!destTy->isMatrixType() || !srcTy->isMatrixType())
3
←
Calling 'Type::isMatrixType'→
6
←
Returning from 'Type::isMatrixType'→
7
←
Calling 'Type::isMatrixType'→
10
←
Returning from 'Type::isMatrixType'→
11
←
Taking false branch→
  return false;

const ConstantMatrixType *matSrcType = srcTy->getAs<ConstantMatrixType>();
12
←
Assuming the object is a 'ConstantMatrixType'→
const ConstantMatrixType *matDestType = destTy->getAs<ConstantMatrixType>();
13
←
Assuming the object is not a 'ConstantMatrixType'→
14
←
'matDestType' initialized to a null pointer value→

return matSrcType->getNumRows() == matDestType->getNumRows() &&
15
←
Called C++ object pointer is null
       matSrcType->getNumColumns() == matDestType->getNumColumns();
7420}

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

uint64_t SrcLen, DestLen;
QualType SrcEltTy, DestEltTy;
if (!breakDownVectorType(SrcTy, SrcLen, SrcEltTy))
  return false;
if (!breakDownVectorType(DestTy, DestLen, DestEltTy))
  return false;

// ASTContext::getTypeSize will return the size rounded up to a
// power of 2, so instead of using that, we need to use the raw
// element size multiplied by the element count.
uint64_t SrcEltSize = Context.getTypeSize(SrcEltTy);
uint64_t DestEltSize = Context.getTypeSize(DestEltTy);

return (SrcLen * SrcEltSize == DestLen * DestEltSize);
7439}

7441/// Are the two types lax-compatible vector types?  That is, given
7442/// that one of them is a vector, do they have equal storage sizes,
7443/// where the storage size is the number of elements times the element
7444/// size?
7445///
7446/// This will also return false if either of the types is neither a
7447/// vector nor a real type.
7448bool Sema::areLaxCompatibleVectorTypes(QualType srcTy, QualType destTy) {
assert(destTy->isVectorType() || srcTy->isVectorType())((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;
if (destTy->isScalarType() && srcTy->isExtVectorType()) return false;

return areVectorTypesSameSize(srcTy, destTy);
7460}

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

switch (Context.getLangOpts().getLaxVectorConversions()) {
case LangOptions::LaxVectorConversionKind::None:
  return false;

case LangOptions::LaxVectorConversionKind::Integer:
  if (!srcTy->isIntegralOrEnumerationType()) {
    auto *Vec = srcTy->getAs<VectorType>();
    if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
      return false;
  }
  if (!destTy->isIntegralOrEnumerationType()) {
    auto *Vec = destTy->getAs<VectorType>();
    if (!Vec || !Vec->getElementType()->isIntegralOrEnumerationType())
      return false;
  }
  // OK, integer (vector) -> integer (vector) bitcast.
  break;

  case LangOptions::LaxVectorConversionKind::All:
  break;
}

return areLaxCompatibleVectorTypes(srcTy, destTy);
7490}

7492bool Sema::CheckMatrixCast(SourceRange R, QualType DestTy, QualType SrcTy,
                         CastKind &Kind) {
if (SrcTy->isMatrixType() && DestTy->isMatrixType()) {
1
Taking true branch→
  if (!areMatrixTypesOfTheSameDimension(SrcTy, DestTy)) {
2
←
Calling 'Sema::areMatrixTypesOfTheSameDimension'→
    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;
7511}

7513bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
                         CastKind &Kind) {
assert(VectorTy->isVectorType() && "Not a vector type!")((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;
7531}

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

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

assert(DestElemTy->isFloatingType() ||((void)0)
       DestElemTy->isIntegralOrEnumerationType())((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);
7564}

7566ExprResult Sema::CheckExtVectorCast(SourceRange R, QualType DestTy,
                                  Expr *CastExpr, CastKind &Kind) {
assert(DestTy->isExtVectorType() && "Not an extended vector type!")((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);
7598}

7600ExprResult
7601Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                  Declarator &D, ParsedType &Ty,
                  SourceLocation RParenLoc, Expr *CastExpr) {
assert(!D.isInvalidType() && (CastExpr != nullptr) &&((void)0)
       "ActOnCastExpr(): missing type or expr")((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);
7673}

7675ExprResult Sema::BuildVectorLiteral(SourceLocation LParenLoc,
                                  SourceLocation RParenLoc, Expr *E,
                                  TypeSourceInfo *TInfo) {
assert((isa<ParenListExpr>(E) || isa<ParenExpr>(E)) &&((void)0)
       "Expected paren or paren list expression")((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")((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 (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);
7753}

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

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

7780/// Emit a specialized diagnostic when one expression is a null pointer
7781/// constant and the other is not a pointer.  Returns true if a diagnostic is
7782/// emitted.
7783bool 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;
7819}

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

7840/// Handle when one or both operands are void type.
7841static 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;
7855}

7857/// Return false if the NullExpr can be promoted to PointerTy,
7858/// true otherwise.
7859static 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;
7868}

7870/// Checks compatibility between two pointers and return the resulting
7871/// type.
7872static 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;
7998}

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

8025/// Return the resulting type when the operands are both pointers.
8026static QualType
8027checkConditionalObjectPointersCompatibility(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);
8062}

8064/// Return false if the first expression is not an integer and the second
8065/// expression is not a pointer, true otherwise.
8066static 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;
8082}

8084/// Simple conversion between integer and floating point types.
8085///
8086/// Used when handling the OpenCL conditional operator where the
8087/// condition is a vector while the other operands are scalar.
8088///
8089/// OpenCL v1.1 s6.3.i and s6.11.6 together require that the scalar
8090/// types are either integer or floating type. Between the two
8091/// operands, the type with the higher rank is defined as the "result
8092/// type". The other operand needs to be promoted to the same type. No
8093/// other type promotion is allowed. We cannot use
8094/// UsualArithmeticConversions() for this purpose, since it always
8095/// promotes promotable types.
8096static 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);
8137}

8139/// Convert scalar operands to a vector that matches the
8140///        condition in length.
8141///
8142/// Used when handling the OpenCL conditional operator where the
8143/// condition is a vector while the other operands are scalar.
8144///
8145/// We first compute the "result type" for the scalar operands
8146/// according to OpenCL v1.1 s6.3.i. Both operands are then converted
8147/// into a vector of that type where the length matches the condition
8148/// vector type. s6.11.6 requires that the element types of the result
8149/// and the condition must have the same number of bits.
8150static QualType
8151OpenCLConvertScalarsToVectors(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)((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;
8182}

8184/// Return false if this is a valid OpenCL condition vector
8185static 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)((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;
8197}

8199/// Return false if the vector condition type and the vector
8200///        result type are compatible.
8201///
8202/// OpenCL v1.1 s6.11.6 requires that both vector types have the same
8203/// number of elements, and their element types have the same number
8204/// of bits.
8205static 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)((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;
8227}

8229/// Return the resulting type for the conditional operator in
8230///        OpenCL (aka "ternary selection operator", OpenCL v1.1
8231///        s6.3.i) when the condition is a vector type.
8232static QualType
8233OpenCLCheckVectorConditional(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);
8262}

8264/// Return true if the Expr is block type
8265static 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;
8274}

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

8444/// FindCompositeObjCPointerType - Helper method to find composite type of
8445/// two objective-c pointer types of the two input expressions.
8446QualType 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();
8584}

8586/// SuggestParentheses - Emit a note with a fixit hint that wraps
8587/// ParenRange in parentheses.
8588static 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;
}
8601}

8603static 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.
8612}

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

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

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

8720/// Compute the nullability of a conditional expression.
8721static 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);
8771}

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

8878// Check if we have a conversion between incompatible cmse function pointer
8879// types, that is, a conversion between a function pointer with the
8880// cmse_nonsecure_call attribute and one without.
8881static 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;
8894}

8896// checkPointerTypesForAssignment - This is a very tricky routine (despite
8897// being closely modeled after the C99 spec:-). The odd characteristic of this
8898// routine is it effectively iqnores the qualifiers on the top level pointee.
8899// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3].
8900// FIXME: add a couple examples in this comment.
8901static Sema::AssignConvertType
8902checkPointerTypesForAssignment(Sema &S, QualType LHSType, QualType RHSType) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")((void)0);
assert(RHSType.isCanonical() && "RHS not canonicalized!")((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())((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())((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;
9037}

9039/// checkBlockPointerTypesForAssignment - This routine determines whether two
9040/// block pointer types are compatible or whether a block and normal pointer
9041/// are compatible. It is more restrict than comparing two function pointer
9042// types.
9043static Sema::AssignConvertType
9044checkBlockPointerTypesForAssignment(Sema &S, QualType LHSType,
                                  QualType RHSType) {
assert(LHSType.isCanonical() && "LHS not canonicalized!")((void)0);
assert(RHSType.isCanonical() && "RHS not canonicalized!")((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;
9090}

9092/// checkObjCPointerTypesForAssignment - Compares two objective-c pointer types
9093/// for assignment compatibility.
9094static Sema::AssignConvertType
9095checkObjCPointerTypesForAssignment(Sema &S, QualType LHSType,
                                 QualType RHSType) {
assert(LHSType.isCanonical() && "LHS was not canonicalized!")((void)0);
assert(RHSType.isCanonical() && "RHS was not canonicalized!")((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;
9126}

9128Sema::AssignConvertType
9129Sema::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);
9140}

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

9150/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently
9151/// has code to accommodate several GCC extensions when type checking
9152/// pointers. Here are some objectionable examples that GCC considers warnings:
9153///
9154///  int a, *pint;
9155///  short *pshort;
9156///  struct foo *pfoo;
9157///
9158///  pint = pshort; // warning: assignment from incompatible pointer type
9159///  a = pint; // warning: assignment makes integer from pointer without a cast
9160///  pint = a; // warning: assignment makes pointer from integer without a cast
9161///  pint = pfoo; // warning: assignment from incompatible pointer type
9162///
9163/// As a result, the code for dealing with pointers is more complex than the
9164/// C99 spec dictates.
9165///
9166/// Sets 'Kind' for any result kind except Incompatible.
9167Sema::AssignConvertType
9168Sema::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;
9485}

9487/// Constructs a transparent union from an expression that is
9488/// used to initialize the transparent union.
9489static 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);
9505}

9507Sema::AssignConvertType
9508Sema::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;
9557}

9559Sema::AssignConvertType
9560Sema::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")((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;
9707}

9709namespace {
9710/// The original operand to an operator, prior to the application of the usual
9711/// arithmetic conversions and converting the arguments of a builtin operator
9712/// candidate.
9713struct 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;
9729};
9730}

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

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

9783/// Try to convert a value of non-vector type to a vector type by converting
9784/// the type to the element type of the vector and then performing a splat.
9785/// If the language is OpenCL, we only use conversions that promote scalar
9786/// rank; for C, Obj-C, and C++ we allow any real scalar conversion except
9787/// for float->int.
9788///
9789/// OpenCL V2.0 6.2.6.p2:
9790/// An error shall occur if any scalar operand type has greater rank
9791/// than the type of the vector element.
9792///
9793/// \param scalar - if non-null, actually perform the conversions
9794/// \return true if the operation fails (but without diagnosing the failure)
9795static 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;
9838}

9840/// Convert vector E to a vector with the same number of elements but different
9841/// element type.
9842static ExprResult convertVector(Expr *E, QualType ElementType, Sema &S) {
const auto *VecTy = E->getType()->getAs<VectorType>();
assert(VecTy && "Expression E must be a vector")((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);
9857}

9859/// Test if a (constant) integer Int can be casted to another integer type
9860/// IntTy without losing precision.
9861static 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);
9895}

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

9939/// Attempt to convert and splat Scalar into a vector whose types matches
9940/// Vector following GCC conversion rules. The rule is that implicit
9941/// conversion can occur when Scalar can be casted to match Vector's element
9942/// type without causing truncation of Scalar.
9943static 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>();

assert(!isa<ExtVectorType>(VT) &&((void)0)
       "ExtVectorTypes should not be handled here!")((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())
  return true;

// The conversion to apply to the scalar before splatting it,
// if necessary.
CastKind ScalarCast = CK_NoOp;

// Accept cases where the vector elements are integers and the scalar is
// an integer.
// FIXME: Notionally if the scalar was a floating point value with a precise
//        integral representation, we could cast it to an appropriate integer
//        type and then perform the rest of the checks here. GCC will perform
//        this conversion in some cases as determined by the input language.
//        We should accept it on a language independent basis.
if (VectorEltTy->isIntegralType(S.Context) &&
    ScalarTy->isIntegralType(S.Context) &&
    S.Context.getIntegerTypeOrder(VectorEltTy, ScalarTy)) {

  if (canConvertIntToOtherIntTy(S, Scalar, VectorEltTy))
    return true;

  ScalarCast = CK_IntegralCast;
} else if (VectorEltTy->isIntegralType(S.Context) &&
           ScalarTy->isRealFloatingType()) {
  if (S.Context.getTypeSize(VectorEltTy) == S.Context.getTypeSize(ScalarTy))
    ScalarCast = CK_FloatingToIntegral;
  else
    return true;
} else if (VectorEltTy->isRealFloatingType()) {
  if (ScalarTy->isRealFloatingType()) {

    // Reject cases where the scalar type is not a constant and has a higher
    // Order than the vector element type.
    llvm::APFloat Result(0.0);

    // Determine whether this is a constant scalar. In the event that the
    // value is dependent (and thus cannot be evaluated by the constant
    // evaluator), skip the evaluation. This will then diagnose once the
    // expression is instantiated.
    bool CstScalar = Scalar->get()->isValueDependent() ||
                     Scalar->get()->EvaluateAsFloat(Result, S.Context);
    int Order = S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
    if (!CstScalar && Order < 0)
      return true;

    // If the scalar cannot be safely casted to the vector element type,
    // reject it.
    if (CstScalar) {
      bool Truncated = false;
      Result.convert(S.Context.getFloatTypeSemantics(VectorEltTy),
                     llvm::APFloat::rmNearestTiesToEven, &Truncated);
      if (Truncated)
        return true;
    }

    ScalarCast = CK_FloatingCast;
  } else if (ScalarTy->isIntegralType(S.Context)) {
    if (canConvertIntTyToFloatTy(S, Scalar, VectorEltTy))
      return true;

    ScalarCast = CK_IntegralToFloating;
  } else
    return true;
} else if (ScalarTy->isEnumeralType())
  return true;

// Adjust scalar if desired.
if (Scalar) {
  if (ScalarCast != CK_NoOp)
    *Scalar = S.ImpCastExprToType(Scalar->get(), VectorEltTy, ScalarCast);
  *Scalar = S.ImpCastExprToType(Scalar->get(), VectorTy, CK_VectorSplat);
}
return false;
10029}

10031QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                 SourceLocation Loc, bool IsCompAssign,
                                 bool AllowBothBool,
                                 bool AllowBoolConversions) {
if (!IsCompAssign) {
  LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
  if (LHS.isInvalid())
    return QualType();
}
RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
if (RHS.isInvalid())
  return QualType();

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

const VectorType *LHSVecType = LHSType->getAs<VectorType>();
const VectorType *RHSVecType = RHSType->getAs<VectorType>();
assert(LHSVecType || RHSVecType)((void)0);

if ((LHSVecType && LHSVecType->getElementType()->isBFloat16Type()) ||
    (RHSVecType && 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 &&
    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))
  return LHSType;

// If we have compatible AltiVec and GCC vector types, use the AltiVec type.
if (LHSVecType && RHSVecType &&
    Context.areCompatibleVectorTypes(LHSType, RHSType)) {
  if (isa<ExtVectorType>(LHSVecType)) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return LHSType;
  }

  if (!IsCompAssign)
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
  return RHSType;
}

// AllowBoolConversions says that bool and non-bool AltiVec vectors
// can be mixed, with the result being the non-bool type.  The non-bool
// operand must have integer element type.
if (AllowBoolConversions && LHSVecType && RHSVecType &&
    LHSVecType->getNumElements() == RHSVecType->getNumElements() &&
    (Context.getTypeSize(LHSVecType->getElementType()) ==
     Context.getTypeSize(RHSVecType->getElementType()))) {
  if (LHSVecType->getVectorKind() == VectorType::AltiVecVector &&
      LHSVecType->getElementType()->isIntegerType() &&
      RHSVecType->getVectorKind() == VectorType::AltiVecBool) {
    RHS = ImpCastExprToType(RHS.get(), LHSType, CK_BitCast);
    return LHSType;
  }
  if (!IsCompAssign &&
      LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
      RHSVecType->getVectorKind() == VectorType::AltiVecVector &&
      RHSVecType->getElementType()->isIntegerType()) {
    LHS = ImpCastExprToType(LHS.get(), RHSType, CK_BitCast);
    return RHSType;
  }
}

// Expressions containing fixed-length and sizeless SVE vectors are invalid
// since the ambiguity can affect the ABI.
auto IsSveConversion = [](QualType FirstType, QualType SecondType) {
  const VectorType *VecType = SecondType->getAs<VectorType>();
  return FirstType->isSizelessBuiltinType() && VecType &&
         (VecType->getVectorKind() == VectorType::SveFixedLengthDataVector ||
          VecType->getVectorKind() ==
              VectorType::SveFixedLengthPredicateVector);
};

if (IsSveConversion(LHSType, RHSType) || IsSveConversion(RHSType, LHSType)) {
  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>();
  const VectorType *SecondVecType = SecondType->getAs<VectorType>();

  if (FirstVecType && SecondVecType)
    return FirstVecType->getVectorKind() == VectorType::GenericVector &&
           (SecondVecType->getVectorKind() ==
                VectorType::SveFixedLengthDataVector ||
            SecondVecType->getVectorKind() ==
                VectorType::SveFixedLengthPredicateVector);

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

if (IsSveGnuConversion(LHSType, RHSType) ||
    IsSveGnuConversion(RHSType, LHSType)) {
  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 (!RHSVecType) {
  if (isa<ExtVectorType>(LHSVecType)) {
    if (!tryVectorConvertAndSplat(*this, &RHS, RHSType,
                                  LHSVecType->getElementType(), LHSType,
                                  DiagID))
      return LHSType;
  } else {
    if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
      return LHSType;
  }
}
if (!LHSVecType) {
  if (isa<ExtVectorType>(RHSVecType)) {
    if (!tryVectorConvertAndSplat(*this, (IsCompAssign ? nullptr : &LHS),
                                  LHSType, RHSVecType->getElementType(),
                                  RHSType, DiagID))
      return RHSType;
  } else {
    if (LHS.get()->isLValue() ||
        !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
      return RHSType;
  }
}

// FIXME: The code below also handles conversion between vectors and
// non-scalars, we should break this down into fine grained specific checks
// and emit proper diagnostics.
QualType VecType = LHSVecType ? LHSType : RHSType;
const VectorType *VT = LHSVecType ? LHSVecType : RHSVecType;
QualType OtherType = LHSVecType ? RHSType : LHSType;
ExprResult *OtherExpr = LHSVecType ? &RHS : &LHS;
if (isLaxVectorConversion(OtherType, VecType)) {
  // If we're allowing lax vector conversions, only the total (data) size
  // needs to be the same. For non compound assignment, if one of the types is
  // scalar, the result is always the vector type.
  if (!IsCompAssign) {
    *OtherExpr = ImpCastExprToType(OtherExpr->get(), VecType, CK_BitCast);
    return VecType;
  // In a compound assignment, lhs += rhs, 'lhs' is a lvalue src, forbidding
  // any implicit cast. Here, the 'rhs' should be implicit casted to 'lhs'
  // type. Note that this is already done by non-compound assignments in
  // CheckAssignmentConstraints. If it's a scalar type, only bitcast for
  // <1 x T> -> T. The result is also a vector type.
  } else if (OtherType->isExtVectorType() || OtherType->isVectorType() ||
             (OtherType->isScalarType() && VT->getNumElements() == 1)) {
    ExprResult *RHSExpr = &RHS;
    *RHSExpr = ImpCastExprToType(RHSExpr->get(), LHSType, CK_BitCast);
    return VecType;
  }
}

// Okay, the expression is invalid.

// If there's a non-vector, non-real operand, diagnose that.
if ((!RHSVecType && !RHSType->isRealType()) ||
    (!LHSVecType && !LHSType->isRealType())) {
  Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
    << LHSType << RHSType
    << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
  return QualType();
}

// OpenCL V1.1 6.2.6.p1:
// If the operands are of more than one vector type, then an error shall
// occur. Implicit conversions between vector types are not permitted, per
// section 6.2.1.
if (getLangOpts().OpenCL &&
    RHSVecType && isa<ExtVectorType>(RHSVecType) &&
    LHSVecType && isa<ExtVectorType>(LHSVecType)) {
  Diag(Loc, diag::err_opencl_implicit_vector_conversion) << LHSType
                                                         << RHSType;
  return QualType();
}


// If there is a vector type that is not a ExtVector and a scalar, we reach
// this point if scalar could not be converted to the vector's element type
// without truncation.
if ((RHSVecType && !isa<ExtVectorType>(RHSVecType)) ||
    (LHSVecType && !isa<ExtVectorType>(LHSVecType))) {
  QualType Scalar = LHSVecType ? RHSType : LHSType;
  QualType Vector = LHSVecType ? LHSType : RHSType;
  unsigned ScalarOrVector = LHSVecType && RHSVecType ? 1 : 0;
  Diag(Loc,
       diag::err_typecheck_vector_not_convertable_implict_truncation)
      << ScalarOrVector << Scalar << Vector;

  return QualType();
}

// Otherwise, use the generic diagnostic.
Diag(Loc, DiagID)
  << LHSType << RHSType
  << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
return QualType();
10239}

10241// checkArithmeticNull - Detect when a NULL constant is used improperly in an
10242// expression.  These are mainly cases where the null pointer is used as an
10243// integer instead of a pointer.
10244static 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();
10278}

10280static 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;
}
10326}

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

10341QualType 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;
10373}

10375QualType 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;
10398}

10400/// Diagnose invalid arithmetic on two void pointers.
10401static 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();
10408}

10410/// Diagnose invalid arithmetic on a void pointer.
10411static 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();
10417}

10419/// Diagnose invalid arithmetic on a null pointer.
10420///
10421/// If \p IsGNUIdiom is true, the operation is using the 'p = (i8*)nullptr + n'
10422/// idiom, which we recognize as a GNU extension.
10423///
10424static 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();
10432}

10434/// Diagnose invalid subraction on a null pointer.
10435///
10436static 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();
10448}

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

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

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

10495/// Check the validity of an arithmetic pointer operand.
10496///
10497/// If the operand has pointer type, this code will check for pointer types
10498/// which are invalid in arithmetic operations. These will be diagnosed
10499/// appropriately, including whether or not the use is supported as an
10500/// extension.
10501///
10502/// \returns True when the operand is valid to use (even if as an extension).
10503static 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;
10524}

10526/// Check the validity of a binary arithmetic operation w.r.t. pointer
10527/// operands.
10528///
10529/// This routine will diagnose any invalid arithmetic on pointer operands much
10530/// like \see checkArithmeticOpPointerOperand. However, it has special logic
10531/// for emitting a single diagnostic even for operations where both LHS and RHS
10532/// are (potentially problematic) pointers.
10533///
10534/// \returns True when the operand is valid to use (even if as an extension).
10535static 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;
10584}

10586/// diagnoseStringPlusInt - Emit a warning when adding an integer to a string
10587/// literal.
10588static 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);
10615}

10617/// Emit a warning when adding a char literal to a string.
10618static 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);
}
10666}

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

10678// C99 6.5.6
10679QualType 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())((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();
10780}

10782// C99 6.5.6
10783QualType 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);
10910}

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

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

11012/// Return the resulting type when a vector is shifted
11013///        by a scalar or vector shift amount.
11014static 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)((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;
11097}

11099// C99 6.5.7
11100QualType 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;
11158}

11160/// Diagnose bad pointer comparisons.
11161static 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();
11168}

11170/// Returns false if the pointers are converted to a composite type,
11171/// true otherwise.
11172static 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() ||((void)0)
       LHSType->isMemberPointerType() || RHSType->isMemberPointerType())((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;
11199}

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

11211static 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;
}
11222}

11224static 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;
11268}

11270Sema::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;
11310}

11312static 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)((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, "]");
}
11359}

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

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

11417/// Diagnose some forms of syntactically-obvious tautological comparison.
11418static 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());
}
11543}

11545static ImplicitConversionKind castKindToImplicitConversionKind(CastKind CK) {
switch (CK) {
default: {
11548#ifndef NDEBUG1
  llvm::errs() << "unhandled cast kind: " << CastExpr::getCastKindName(CK)
               << "\n";
11551#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;
}
11580}

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

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

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

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

11734void 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");
    }
}
11758}

11760// C99 6.5.8, C++ [expr.rel]
11761QualType 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)((void)0);
  assert(Context.hasSameType(LHS.get()->getType(), RHS.get()->getType()))((void)0);

  QualType CompositeTy = LHS.get()->getType();
  assert(!CompositeTy->isReferenceType())((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().OpenCLVersion >= 200 || getLangOpts().OpenCLCPlusPlus) {
  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);
12215}

12217// Return a signed ext_vector_type that is of identical size and number of
12218// elements. For floating point vectors, return an integer type of identical
12219// size and number of elements. In the non ext_vector_type case, search from
12220// the largest type to the smallest type to avoid cases where long long == long,
12221// where long gets picked over long long.
12222QualType 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) &&((void)0)
         "Unhandled vector element size in vector compare")((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) &&((void)0)
       "Unhandled vector element size in vector compare")((void)0);
return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
                             VectorType::GenericVector);
12256}

12258/// CheckVectorCompareOperands - vector comparisons are a clang extension that
12259/// operates on extended vector types.  Instead of producing an IntTy result,
12260/// like a scalar comparison, a vector comparison produces a vector of integer
12261/// types.
12262QualType 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())((void)0);
  CheckFloatComparison(Loc, LHS.get(), RHS.get());
}

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

12321static 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;
}
12442}

12444QualType 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().OpenCLVersion < 120 &&
    !getLangOpts().OpenCLCPlusPlus && 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());
12464}

12466QualType 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")((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);
12510}

12512QualType 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")((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);
12541}

12543inline 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);
12582}

12584// C99 6.5.[13,14]
12585inline 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;
12686}

12688static 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;
12696}

12698/// Is the given expression (which must be 'const') a reference to a
12699/// variable which was originally non-const, but which has become
12700/// 'const' due to being captured within a block?
12701enum NonConstCaptureKind { NCCK_None, NCCK_Block, NCCK_Lambda };
12702static NonConstCaptureKind isReferenceToNonConstCapture(Sema &S, Expr *E) {
assert(E->isLValue() && E->getType().isConstQualified())((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?")((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);
12736}

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

12745// Update err_typecheck_assign_const and note_typecheck_assign_const
12746// when this enum is changed.
12747enum {
ConstFunction,
ConstVariable,
ConstMember,
ConstMethod,
NestedConstMember,
ConstUnknown,  // Keep as last element
12754};

12756/// Emit the "read-only variable not assignable" error and print notes to give
12757/// more information about why the variable is not assignable, such as pointing
12758/// to the declaration of a const variable, showing that a method is const, or
12759/// that the function is returning a const reference.
12760static 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.")((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;
12877}

12879enum OriginalExprKind {
OEK_Variable,
OEK_Member,
OEK_LValue
12883};

12885static 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;
}
12922}

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

12947/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,
12948/// emit an error and return true.  If so, return false.
12949static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {
assert(!E->hasPlaceholderType(BuiltinType::PseudoObject))((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;
13075}

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

13121// C99 6.5.16.1
13122QualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS,
                                     SourceLocation Loc,
                                     QualType CompoundType) {
assert(!LHSExpr->hasPlaceholderType(BuiltinType::PseudoObject))((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());
13253}

13255// Only ignore explicit casts to void.
13256static 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;
13272}

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

13325// C99 6.5.17
13326static 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();
13358}

13360/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine
13361/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions.
13362static 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")((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();
}
13449}


13452/// getPrimaryDecl - Helper function for CheckAddressOfOperand().
13453/// This routine allows us to typecheck complex/recursive expressions
13454/// where the declaration is needed for type checking. We only need to
13455/// handle cases when the expression references a function designator
13456/// or is an lvalue. Here are some examples:
13457///  - &(x) => x
13458///  - &*****f => f for f a function designator.
13459///  - &s.xx => s
13460///  - &s.zz[1].yy -> s, if zz is an array
13461///  - *(x + 1) -> x, if x is an array
13462///  - &"123"[2] -> 0
13463///  - & __real__ x -> x
13464///
13465/// FIXME: We don't recurse to the RHS of a comma, nor handle pointers to
13466/// members.
13467static 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;
}
13512}

13514namespace {
13515enum {
AO_Bit_Field = 0,
AO_Vector_Element = 1,
AO_Property_Expansion = 2,
AO_Register_Variable = 3,
AO_Matrix_Element = 4,
AO_No_Error = 5
13522};
13523}
13524/// Diagnose invalid operand for address of operations.
13525///
13526/// \param Type The type of operand which cannot have its address taken.
13527static void diagnoseAddressOfInvalidType(Sema &S, SourceLocation Loc,
                                       Expr *E, unsigned Type) {
S.Diag(Loc, diag::err_typecheck_address_of) << Type << E->getSourceRange();
13530}

13532/// CheckAddressOfOperand - The operand of & must be either a function
13533/// designator or an lvalue designating an object. If it is an lvalue, the
13534/// object cannot be declared with storage class register or be a bit field.
13535/// Note: The usual conversions are *not* applied to the operand of the &
13536/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
13537/// In C++, the operand might be an overloaded function name, in which case
13538/// we allow the '&' but retain the overloaded-function type.
13539QualType 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)((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())((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());
13756}

13758static 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);
13774}

13776/// CheckIndirectionOperand - Type check unary indirection (prefix '*').
13777static 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;
13836}

13838BinaryOperatorKind 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;
13877}

13879static 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;
13897}

13899/// DiagnoseSelfAssignment - Emits a warning if a value is assigned to itself.
13900/// This warning suppressed in the event of macro expansions.
13901static 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();
13933}

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

13978static 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;
13988}

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

14025static std::pair<ExprResult, ExprResult>
14026CorrectDelayedTyposInBinOp(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);
14045}

14047/// Returns true if conversion between vectors of halfs and vectors of floats
14048/// is needed.
14049static 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));
14071}

14073/// CreateBuiltinBinOp - Creates a new built-in binary operation with
14074/// operator @p Opc at location @c TokLoc. This routine only supports
14075/// built-in operations; ActOnBinOp handles overloaded operators.
14076ExprResult 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())((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(((void)0)
    (Opc == BO_Comma || isVector(RHS.get()->getType(), Context.HalfTy) ==((void)0)
                            isVector(LHS.get()->getType(), Context.HalfTy)) &&((void)0)
    "both sides are half vectors or neither sides are")((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);
14346}

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

14391/// It accepts a '&&' expr that is inside a '||' one.
14392/// Emit a diagnostic together with a fixit hint that wraps the '&&' expression
14393/// in parentheses.
14394static void
14395EmitDiagnosticForLogicalAndInLogicalOr(Sema &Self, SourceLocation OpLoc,
                                     BinaryOperator *Bop) {
assert(Bop->getOpcode() == BO_LAnd)((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());
14404}

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

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

14422/// Look for '&&' in the left hand of a '||' expr.
14423static 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);
    }
  }
}
14442}

14444/// Look for '&&' in the right hand of a '||' expr.
14445static 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);
  }
}
14457}

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

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

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

14517/// DiagnoseBinOpPrecedence - Emit warnings for expressions with tricky
14518/// precedence.
14519static 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);
14551}

14553// Binary Operators.  'Tok' is the token for the operator.
14554ExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc,
                          tok::TokenKind Kind,
                          Expr *LHSExpr, Expr *RHSExpr) {
BinaryOperatorKind Opc = ConvertTokenKindToBinaryOpcode(Kind);
assert(LHSExpr && "ActOnBinOp(): missing left expression")((void)0);
assert(RHSExpr && "ActOnBinOp(): missing right expression")((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);
14565}

14567void 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);
}
14578}

14580/// Build an overloaded binary operator expression in the given scope.
14581static 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);
14606}

14608ExprResult 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)((void)0);
  assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&((void)0)
         "Should only occur in error-recovery path.")((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);
14753}

14755static 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);
14763}

14765ExprResult 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().OpenCLVersion < 120 &&
        !Context.getLangOpts().OpenCLCPlusPlus) {
      // 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() &&((void)0)
                 "the co_await expression must be non-dependant before "((void)0)
                 "building operator co_await")((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;
14986}

14988/// Determine whether the given expression is a qualified member
14989/// access expression, of a form that could be turned into a pointer to member
14990/// with the address-of operator.
14991bool 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;
15026}

15028ExprResult 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);
15069}

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

15077/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
15078ExprResult 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));
15084}

15086void Sema::ActOnStartStmtExpr() {
PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
15088}

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

DiscardCleanupsInEvaluationContext();
PopExpressionEvaluationContext();
15096}

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

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

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

15142ExprResult 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);
15171}

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

15336ExprResult 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);
15352}


15355ExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc,
                               Expr *CondExpr,
                               Expr *LHSExpr, Expr *RHSExpr,
                               SourceLocation RPLoc) {
assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)")((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);
15387}

15389//===----------------------------------------------------------------------===//
15390// Clang Extensions.
15391//===----------------------------------------------------------------------===//

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

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

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

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

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

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

15745ExprResult 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);
15895}

15897ExprResult 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);
15913}

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

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

15929bool 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;
15982}

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

16003bool 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;
16278}

16280ExprResult 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);
16296}

16298ExprResult 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);
16315}

16317Sema::SemaDiagnosticBuilder
16318Sema::VerifyICEDiagnoser::diagnoseNotICEType(Sema &S, SourceLocation Loc,
                                           QualType T) {
return diagnoseNotICE(S, Loc);
16321}

16323Sema::SemaDiagnosticBuilder
16324Sema::VerifyICEDiagnoser::diagnoseFold(Sema &S, SourceLocation Loc) {
return S.Diag(Loc, diag::ext_expr_not_ice) << S.LangOpts.CPlusPlus;
16326}

16328ExprResult
16329Sema::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;
16467}

16469namespace {
// 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);
  }
};
16515}

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

16527void
16528Sema::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);
16536}

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

16546namespace {

16548const 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;
16571}

16573} // namespace

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

16591/// Check whether E, which is either a discarded-value expression or an
16592/// unevaluated operand, is a simple-assignment to a volatlie-qualified lvalue,
16593/// and if so, remove it from the list of volatile-qualified assignments that
16594/// we are going to warn are deprecated.
16595void 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());
  }
}
16609}

16611ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
if (!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;
16634}

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

16664static 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() &&((void)0)
           "ConstantExpr marked IsImmediateInvocation should "((void)0)
           "be present")((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())((void)0);
Res = SemaRef.MaybeCreateExprWithCleanups(Res);
It->getPointer()->setSubExpr(Res.get());
16740}

16742static void
16743HandleImmediateInvocations(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);
}
16789}

16791void 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;
16857}

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

16867ExprResult 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);
16875}

16877/// Are we in a context that is potentially constant evaluated per C++20
16878/// [expr.const]p12?
16879static 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();
16904}

16906/// Return true if this function has a calling convention that requires mangling
16907/// in the size of the parameter pack.
16908static 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;
16932}

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

16980namespace {
16981enum 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
16991};
16992}

16994/// Are we within a context in which references to resolved functions or to
16995/// variables result in odr-use?
16996static 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;
17025}

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

17037/// Mark a function referenced, and check whether it is odr-used
17038/// (C++ [basic.def.odr]p2, C99 6.9p3)
17039void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
                                bool MightBeOdrUse) {
assert(Func && "No function?")((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);
}
17278}

17280/// Directly mark a variable odr-used. Given a choice, prefer to use
17281/// MarkVariableReferenced since it does additional checks and then
17282/// calls MarkVarDeclODRUsed.
17283/// If the variable must be captured:
17284///  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
17285///  - else capture it in the DeclContext that maps to the
17286///    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
17287static void
17288MarkVarDeclODRUsed(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);
17346}

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

17354static void
17355diagnoseUncapturableValueReference(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.
17394}


17397static 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;
17424}

17426// Only block literals, captured statements, and lambda expressions can
17427// capture; other scopes don't work.
17428static 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;
17438}

17440// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture
17441// certain types of variables (unnamed, variably modified types etc.)
17442// so check for eligibility.
17443static 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;
17503}

17505// Returns true if the capture by block was successful.
17506static 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;
17574}


17577/// Capture the given variable in the captured region.
17578static 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;
17615}

17617/// Capture the given variable in the lambda.
17618static 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;
17715}

17717static 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;
17736}

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

17818bool 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 &&((void)0)
                   "Wrong number of captured regions associated with the "((void)0)
                   "OpenMP construct.")((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;
18055}

18057bool 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);
18064}

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

18074QualType 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;
18085}

18087namespace {
18088// Helper to copy the template arguments from a DeclRefExpr or MemberExpr.
18089// The produced TemplateArgumentListInfo* points to data stored within this
18090// object, so should only be used in contexts where the pointer will not be
18091// used after the CopiedTemplateArgs object is destroyed.
18092class CopiedTemplateArgs {
bool HasArgs;
TemplateArgumentListInfo TemplateArgStorage;
18095public:
template<typename RefExpr>
CopiedTemplateArgs(RefExpr *E) : HasArgs(E->hasExplicitTemplateArgs()) {
  if (HasArgs)
    E->copyTemplateArgumentsInto(TemplateArgStorage);
}
operator TemplateArgumentListInfo*()
18102#ifdef __has_cpp_attribute
18103#if0 __has_cpp_attribute(clang::lifetimebound)1
[[clang::lifetimebound]]
18105#endif
18106#endif
{
  return HasArgs ? &TemplateArgStorage : nullptr;
}
18110};
18111}

18113/// Walk the set of potential results of an expression and mark them all as
18114/// non-odr-uses if they satisfy the side-conditions of the NonOdrUseReason.
18115///
18116/// \return A new expression if we found any potential results, ExprEmpty() if
18117///         not, and ExprError() if we diagnosed an error.
18118static 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);
  return ExprEmpty();
}

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

18436ExprResult 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;
18457}

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

18472void 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() &&((void)0)
       "MarkVarDeclODRUsed failed to cleanup MaybeODRUseExprs?")((void)0);
18495}

18497static void DoMarkVarDeclReferenced(
  Sema &SemaRef, SourceLocation Loc, VarDecl *Var, Expr *E,
  llvm::DenseMap<const VarDecl *, int> &RefsMinusAssignments) {
assert((!E || isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||((void)0)
        isa<FunctionParmPackExpr>(E)) &&((void)0)
       "Invalid Expr argument to DoMarkVarDeclReferenced")((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) &&((void)0)
       "Can't instantiate a partial template specialization.")((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)) &&((void)0)
         "missing non-odr-use marking for unevaluated decl ref")((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.")((void)0);
      if (!Var->getType()->isReferenceType() ||
          !Var->isUsableInConstantExpressions(SemaRef.Context))
        LSI->addPotentialCapture(E->IgnoreParens());
    }
  }
  break;
}
18669}

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

18678static void
18679MarkExprReferenced(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);
18712}

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

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

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

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

18782namespace {
// 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);
};
18801}

18803bool 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);
18818}

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

18825namespace {
18826/// Helper class that marks all of the declarations referenced by
18827/// potentially-evaluated subexpressions as "referenced".
18828class EvaluatedExprMarker : public UsedDeclVisitor<EvaluatedExprMarker> {
18829public:
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());
}
18858};
18859} // namespace

18861/// Mark any declarations that appear within this expression or any
18862/// potentially-evaluated subexpressions as "referenced".
18863///
18864/// \param SkipLocalVariables If true, don't mark local variables as
18865/// 'referenced'.
18866void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
                                          bool SkipLocalVariables) {
EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
18869}

18871/// Emit a diagnostic that describes an effect on the run-time behavior
18872/// of the program being compiled.
18873///
18874/// This routine emits the given diagnostic when the code currently being
18875/// type-checked is "potentially evaluated", meaning that there is a
18876/// possibility that the code will actually be executable. Code in sizeof()
18877/// expressions, code used only during overload resolution, etc., are not
18878/// potentially evaluated. This routine will suppress such diagnostics or,
18879/// in the absolutely nutty case of potentially potentially evaluated
18880/// expressions (C++ typeid), queue the diagnostic to potentially emit it
18881/// later.
18882///
18883/// This routine should be used for all diagnostics that describe the run-time
18884/// behavior of a program, such as passing a non-POD value through an ellipsis.
18885/// Failure to do so will likely result in spurious diagnostics or failures
18886/// during overload resolution or within sizeof/alignof/typeof/typeid.
18887bool 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;
18928}

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

18936bool 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;
18975}

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

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

19064ExprResult 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;
19093}

19095Sema::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);
19128}

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

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

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

    assert(E->isPRValue())((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());
  }
};
19206}

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

19216namespace {
/// 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)((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())((void)0);
    assert(E->getObjectKind() == OK_Ordinary)((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());
  }
};
19304}

19306/// Rebuilds a call expression which yielded __unknown_anytype.
19307ExprResult 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))((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)((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) {
      Expr *Arg = E->getArg(i);
      QualType ArgType = Arg->getType();
      if (E->isLValue()) {
        ArgType = S.Context.getLValueReferenceType(ArgType);
      } else if (E->isXValue()) {
        ArgType = S.Context.getRValueReferenceType(ArgType);
      }
      ArgTypes.push_back(ArgType);
    }
    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);
19414}

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

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

return S.MaybeBindToTemporary(E);
19435}

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

  assert(isa<BlockPointerType>(E->getType()))((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();
}
19472}

19474ExprResult 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, 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;
19560}

19562/// Check a cast of an unknown-any type.  We intentionally only
19563/// trigger this for C-style casts.
19564ExprResult 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;
19582}

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

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

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

19654/// Check for operands with placeholder types and complain if found.
19655/// Returns ExprError() if there was an error and no recovery was possible.
19656ExprResult 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.
19763#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
19765#include "clang/Basic/OpenCLImageTypes.def"
19766#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
19768#include "clang/Basic/OpenCLExtensionTypes.def"
19769#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
19771#include "clang/Basic/AArch64SVEACLETypes.def"
19772#define PPC_VECTOR_TYPE(Name, Id, Size) \
case BuiltinType::Id:
19774#include "clang/Basic/PPCTypes.def"
19775#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
19776#include "clang/Basic/RISCVVTypes.def"
19777#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
19778#define PLACEHOLDER_TYPE(Id, SingletonId)
19779#include "clang/AST/BuiltinTypes.def"
  break;
}

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

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

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

19815ExprResult 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);
19846}

19848ExprResult 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);
19862}

←

/usr/src/gnu/usr.bin/clang/libclangSema/../../../llvm/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")((void)0);
  Mask = (Mask & ~CVRMask) | mask;
}
void removeCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask &= ~mask;
}
void removeCVRQualifiers() {
  removeCVRQualifiers(CVRMask);
}
void addCVRQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((void)0);
  Mask |= mask;
}
void addCVRUQualifiers(unsigned mask) {
  assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((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)((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)((void)0);
  assert(!hasObjCLifetime())((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())((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)((void)0);
  Mask = (Mask & ~AddressSpaceMask)
       | (((uint32_t) space) << AddressSpaceShift);
}
void removeAddressSpace() { setAddressSpace(LangAS::Default); }
void addAddressSpace(LangAS space) {
  assert(space != LangAS::Default)((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")((void)0);
  Mask = (Mask & ~FastMask) | mask;
}
void removeFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((void)0);
  Mask &= ~mask;
}
void removeFastQualifiers() {
  removeFastQualifiers(FastMask);
}
void addFastQualifiers(unsigned mask) {
  assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((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() ||((void)0)
         !hasAddressSpace() || !qs.hasAddressSpace())((void)0);
  assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((void)0)
         !hasObjCGCAttr() || !qs.hasObjCGCAttr())((void)0);
  assert(getObjCLifetime() == qs.getObjCLifetime() ||((void)0)
         !hasObjCLifetime() || !qs.hasObjCLifetime())((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));
}

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

589private:
// 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;
603};

605/// A std::pair-like structure for storing a qualified type split
606/// into its local qualifiers and its locally-unqualified type.
607struct 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;
}
630};

632/// The kind of type we are substituting Objective-C type arguments into.
633///
634/// The kind of substitution affects the replacement of type parameters when
635/// no concrete type information is provided, e.g., when dealing with an
636/// unspecialized type.
637enum 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,
652};

654/// A (possibly-)qualified type.
655///
656/// For efficiency, we don't store CV-qualified types as nodes on their
657/// own: instead each reference to a type stores the qualifiers.  This
658/// greatly reduces the number of nodes we need to allocate for types (for
659/// example we only need one for 'int', 'const int', 'volatile int',
660/// 'const volatile int', etc).
661///
662/// As an added efficiency bonus, instead of making this a pair, we
663/// just store the two bits we care about in the low bits of the
664/// pointer.  To handle the packing/unpacking, we make QualType be a
665/// simple wrapper class that acts like a smart pointer.  A third bit
666/// indicates whether there are extended qualifiers present, in which
667/// case the pointer points to a special structure.
668class 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")((void)0);
  auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
  CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
  return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}

690public:
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)((void)0)
         && "non-fast qualifier bits set in mask!")((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")((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;

1289private:
// 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);
1306};

1308} // namespace clang

1310namespace llvm {

1312/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313/// to a specific Type class.
1314template<> struct simplify_type< ::clang::QualType> {
using SimpleType = const ::clang::Type *;

static SimpleType getSimplifiedValue(::clang::QualType Val) {
  return Val.getTypePtr();
}
1320};

1322// Teach SmallPtrSet that QualType is "basically a pointer".
1323template<>
1324struct 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;
1335};

1337} // namespace llvm

1339namespace clang {

1341/// Base class that is common to both the \c ExtQuals and \c Type
1342/// classes, which allows \c QualType to access the common fields between the
1343/// two.
1344class 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) {}
1361};

1363/// We can encode up to four bits in the low bits of a
1364/// type pointer, but there are many more type qualifiers that we want
1365/// to be able to apply to an arbitrary type.  Therefore we have this
1366/// struct, intended to be heap-allocated and used by QualType to
1367/// store qualifiers.
1368///
1369/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370/// in three low bits on the QualType pointer; a fourth bit records whether
1371/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372/// Objective-C GC attributes) are much more rare.
1373class 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; }

1393public:
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
    : ExtQualsTypeCommonBase(baseType,
                             canon.isNull() ? QualType(this_(), 0) : canon),
      Quals(quals) {
  assert(Quals.hasNonFastQualifiers()((void)0)
         && "ExtQuals created with no fast qualifiers")((void)0);
  assert(!Quals.hasFastQualifiers()((void)0)
         && "ExtQuals created with fast qualifiers")((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; }

1419public:
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!")((void)0);
  ID.AddPointer(BaseType);
  Quals.Profile(ID);
}
1431};

1433/// The kind of C++11 ref-qualifier associated with a function type.
1434/// This determines whether a member function's "this" object can be an
1435/// lvalue, rvalue, or neither.
1436enum 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
1445};

1447/// Which keyword(s) were used to create an AutoType.
1448enum class AutoTypeKeyword {
/// auto
Auto,

/// decltype(auto)
DecltypeAuto,

/// __auto_type (GNU extension)
GNUAutoType
1457};

1459/// The base class of the type hierarchy.
1460///
1461/// A central concept with types is that each type always has a canonical
1462/// type.  A canonical type is the type with any typedef names stripped out
1463/// of it or the types it references.  For example, consider:
1464///
1465///  typedef int  foo;
1466///  typedef foo* bar;
1467///    'int *'    'foo *'    'bar'
1468///
1469/// There will be a Type object created for 'int'.  Since int is canonical, its
1470/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1471/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1472/// there is a PointerType that represents 'int*', which, like 'int', is
1473/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1474/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475/// is also 'int*'.
1476///
1477/// Non-canonical types are useful for emitting diagnostics, without losing
1478/// information about typedefs being used.  Canonical types are useful for type
1479/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480/// about whether something has a particular form (e.g. is a function type),
1481/// because they implicitly, recursively, strip all typedefs out of a type.
1482///
1483/// Types, once created, are immutable.
1484///
1485class alignas(8) Type : public ExtQualsTypeCommonBase {
1486public:
enum TypeClass {
1488#define TYPE(Class, Base) Class,
1489#define LAST_TYPE(Class) TypeLast = Class
1490#define ABSTRACT_TYPE(Class, Base)
1491#include "clang/AST/TypeNodes.inc"
};

1494private:
/// 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")((void)0);
    return static_cast<Linkage>(CachedLinkage);
  }

  bool hasLocalOrUnnamedType() const {
    assert(isCacheValid() && "getting linkage from invalid cache")((void)0);
    return CachedLocalOrUnnamed;
  }
};
enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };

1535protected:
// 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;
};

1807private:
template <class T> friend class TypePropertyCache;

/// Set whether this type comes from an AST file.
void setFromAST(bool V = true) const {
  TypeBits.FromAST = V;
}

1815protected:
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); }

1842public:
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

2105#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
bool is##Id##Type() const;
2107#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

2117#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
bool is##Id##Type() const;
2119#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;
2458};

2460/// This will check for a TypedefType by removing any existing sugar
2461/// until it reaches a TypedefType or a non-sugared type.
2462template <> const TypedefType *Type::getAs() const;

2464/// This will check for a TemplateSpecializationType by removing any
2465/// existing sugar until it reaches a TemplateSpecializationType or a
2466/// non-sugared type.
2467template <> const TemplateSpecializationType *Type::getAs() const;

2469/// This will check for an AttributedType by removing any existing sugar
2470/// until it reaches an AttributedType or a non-sugared type.
2471template <> const AttributedType *Type::getAs() const;

2473// We can do canonical leaf types faster, because we don't have to
2474// worry about preserving child type decoration.
2475#define TYPE(Class, Base)
2476#define LEAF_TYPE(Class) \
2477template <> inline const Class##Type *Type::getAs() const { \
return dyn_cast<Class##Type>(CanonicalType); \
2479} \
2480template <> inline const Class##Type *Type::castAs() const { \
return cast<Class##Type>(CanonicalType); \
2482}
2483#include "clang/AST/TypeNodes.inc"

2485/// This class is used for builtin types like 'int'.  Builtin
2486/// types are always canonical and have a literal name field.
2487class BuiltinType : public Type {
2488public:
enum Kind {
2490// OpenCL image types
2491#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492#include "clang/Basic/OpenCLImageTypes.def"
2493// OpenCL extension types
2494#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495#include "clang/Basic/OpenCLExtensionTypes.def"
2496// SVE Types
2497#define SVE_TYPE(Name, Id, SingletonId) Id,
2498#include "clang/Basic/AArch64SVEACLETypes.def"
2499// PPC MMA Types
2500#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501#include "clang/Basic/PPCTypes.def"
2502// RVV Types
2503#define RVV_TYPE(Name, Id, SingletonId) Id,
2504#include "clang/Basic/RISCVVTypes.def"
2505// All other builtin types
2506#define BUILTIN_TYPE(Id, SingletonId) Id,
2507#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508#include "clang/AST/BuiltinTypes.def"
};

2511private:
friend class ASTContext; // ASTContext creates these.

BuiltinType(Kind K)
    : Type(Builtin, QualType(),
           K == Dependent ? TypeDependence::DependentInstantiation
                          : TypeDependence::None) {
  BuiltinTypeBits.Kind = K;
}

2521public:
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')((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; }
2577};

2579/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2580/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581class 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) {}

2590public:
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; }
2605};

2607/// Sugar for parentheses used when specifying types.
2608class 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) {}

2616public:
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; }
2631};

2633/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634class 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) {}

2643public:
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; }
2658};

2660/// Represents a type which was implicitly adjusted by the semantic
2661/// engine for arbitrary reasons.  For example, array and function types can
2662/// decay, and function types can have their calling conventions adjusted.
2663class AdjustedType : public Type, public llvm::FoldingSetNode {
QualType OriginalTy;
QualType AdjustedTy;

2667protected:
friend class ASTContext; // ASTContext creates these.

AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
             QualType CanonicalPtr)
    : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
      OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}

2675public:
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;
}
2694};

2696/// Represents a pointer type decayed from an array or function type.
2697class DecayedType : public AdjustedType {
friend class ASTContext; // ASTContext creates these.

inline
DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);

2703public:
QualType getDecayedType() const { return getAdjustedType(); }

inline QualType getPointeeType() const;

static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709};

2711/// Pointer to a block type.
2712/// This type is to represent types syntactically represented as
2713/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714class 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) {}

2724public:
// 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;
}
2742};

2744/// Base for LValueReferenceType and RValueReferenceType
2745class ReferenceType : public Type, public llvm::FoldingSetNode {
QualType PointeeType;

2748protected:
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
              bool SpelledAsLValue)
    : Type(tc, CanonicalRef, Referencee->getDependence()),
      PointeeType(Referencee) {
  ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
  ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
}

2757public:
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;
}
2786};

2788/// An lvalue reference type, per C++11 [dcl.ref].
2789class LValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

LValueReferenceType(QualType Referencee, QualType CanonicalRef,
                    bool SpelledAsLValue)
    : ReferenceType(LValueReference, Referencee, CanonicalRef,
                    SpelledAsLValue) {}

2797public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == LValueReference;
}
2804};

2806/// An rvalue reference type, per C++11 [dcl.ref].
2807class RValueReferenceType : public ReferenceType {
friend class ASTContext; // ASTContext creates these

RValueReferenceType(QualType Referencee, QualType CanonicalRef)
     : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}

2813public:
bool isSugared() const { return false; }
QualType desugar() const { return QualType(this, 0); }

static bool classof(const Type *T) {
  return T->getTypeClass() == RValueReference;
}
2820};

2822/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823///
2824/// This includes both pointers to data members and pointer to member functions.
2825class 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) {}

2840public:
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;
}
2874};

2876/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877class ArrayType : public Type, public llvm::FoldingSetNode {
2878public:
/// 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
};

2887private:
/// The element type of the array.
QualType ElementType;

2891protected:
friend class ASTContext; // ASTContext creates these.

ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
          unsigned tq, const Expr *sz = nullptr);

2897public:
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;
}
2918};

2920/// Represents the canonical version of C arrays with a specified constant size.
2921/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922/// ConstantArrayType where the element type is 'int' and the size is 404.
2923class 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")((void)0);
    *getTrailingObjects<const Expr*>() = sz;
  }
}

unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
  return ConstantArrayTypeBits.HasStoredSizeExpr;
}

2945public:
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;
}
2978};

2980/// Represents a C array with an unspecified size.  For example 'int A[]' has
2981/// an IncompleteArrayType where the element type is 'int' and the size is
2982/// unspecified.
2983class IncompleteArrayType : public ArrayType {
friend class ASTContext; // ASTContext creates these.

IncompleteArrayType(QualType et, QualType can,
                    ArraySizeModifier sm, unsigned tq)
    : ArrayType(IncompleteArray, et, can, sm, tq) {}

2990public:
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);
}
3011};

3013/// Represents a C array with a specified size that is not an
3014/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3015/// Since the size expression is an arbitrary expression, we store it as such.
3016///
3017/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018/// should not be: two lexically equivalent variable array types could mean
3019/// different things, for example, these variables do not have the same type
3020/// dynamically:
3021///
3022/// void foo(int x) {
3023///   int Y[x];
3024///   ++x;
3025///   int Z[x];
3026/// }
3027class 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) {}

3043public:
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();
}
3066};

3068/// Represents an array type in C++ whose size is a value-dependent expression.
3069///
3070/// For example:
3071/// \code
3072/// template<typename T, int Size>
3073/// class array {
3074///   T data[Size];
3075/// };
3076/// \endcode
3077///
3078/// For these types, we won't actually know what the array bound is
3079/// until template instantiation occurs, at which point this will
3080/// become either a ConstantArrayType or a VariableArrayType.
3081class 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);

3100public:
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);
3128};

3130/// Represents an extended address space qualifier where the input address space
3131/// value is dependent. Non-dependent address spaces are not represented with a
3132/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133///
3134/// For example:
3135/// \code
3136/// template<typename T, int AddrSpace>
3137/// class AddressSpace {
3138///   typedef T __attribute__((address_space(AddrSpace))) type;
3139/// }
3140/// \endcode
3141class 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);

3153public:
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);
3171};

3173/// Represents an extended vector type where either the type or size is
3174/// dependent.
3175///
3176/// For example:
3177/// \code
3178/// template<typename T, int Size>
3179/// class vector {
3180///   typedef T __attribute__((ext_vector_type(Size))) type;
3181/// }
3182/// \endcode
3183class 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);

3197public:
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);
3215};


3218/// Represents a GCC generic vector type. This type is created using
3219/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220/// bytes; or from an Altivec __vector or vector declaration.
3221/// Since the constructor takes the number of vector elements, the
3222/// client is responsible for converting the size into the number of elements.
3223class VectorType : public Type, public llvm::FoldingSetNode {
3224public:
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
};

3251protected:
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);

3263public:
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;
}
3291};

3293/// Represents a vector type where either the type or size is dependent.
3294////
3295/// For example:
3296/// \code
3297/// template<typename T, int Size>
3298/// class vector {
3299///   typedef T __attribute__((vector_size(Size))) type;
3300/// }
3301/// \endcode
3302class 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);

3314public:
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);
3336};

3338/// ExtVectorType - Extended vector type. This type is created using
3339/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341/// class enables syntactic extensions, like Vector Components for accessing
3342/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343/// Shading Language).
3344class ExtVectorType : public VectorType {
friend class ASTContext; // ASTContext creates these.

ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
    : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}

3350public:
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;
}
3408};

3410/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412/// number of rows and "columns" specifies the number of columns.
3413class MatrixType : public Type, public llvm::FoldingSetNode {
3414protected:
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);

3425public:
/// 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;
}
3446};

3448/// Represents a concrete matrix type with constant number of rows and columns
3449class ConstantMatrixType final : public MatrixType {
3450protected:
friend class ASTContext;

/// The element type of the matrix.
// FIXME: Appears to be unused? There is also MatrixType::ElementType...
QualType ElementType;

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

3469public:
/// 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;
}
3508};

3510/// Represents a matrix type where the type and the number of rows and columns
3511/// is dependent on a template.
3512class 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);

3525public:
QualType getElementType() const { return ElementType; }
Expr *getRowExpr() const { return RowExpr; }
Expr *getColumnExpr() const { return ColumnExpr; }
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() == 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);
3544};

3546/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3547/// class of FunctionNoProtoType and FunctionProtoType.
3548class FunctionType : public Type {
// The type returned by the function.
QualType ResultType;

3552public:
/// 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")((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")((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;
};

3799protected:
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);
}

3810public:
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;
}
3845};

3847/// Represents a K&R-style 'int foo()' function, which has
3848/// no information available about its arguments.
3849class 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) {}

3859public:
// 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;
}
3878};

3880/// Represents a prototype with parameter type info, e.g.
3881/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3882/// parameters, not as having a single void parameter. Such a type can have
3883/// an exception specification, but this specification is not part of the
3884/// canonical type. FunctionProtoType has several trailing objects, some of
3885/// which optional. For more information about the trailing objects see
3886/// the first comment inside FunctionProtoType.
3887class 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.

3939public:
/// 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;
  }
};

3992private:
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;
}

4096public:
unsigned getNumParams() const { return FunctionTypeBits.NumParams; }

QualType getParamType(unsigned i) const {
  assert(i < getNumParams() && "invalid parameter index")((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!")((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())((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")((void)0);
  if (hasExtParameterInfos())
    return getTrailingObjects<ExtParameterInfo>()[I];
  return ExtParameterInfo();
}

ParameterABI getParameterABI(unsigned I) const {
  assert(I < getNumParams() && "parameter index out of range")((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")((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);
4336};

4338/// Represents the dependent type named by a dependently-scoped
4339/// typename using declaration, e.g.
4340///   using typename Base<T>::foo;
4341///
4342/// Template instantiation turns these into the underlying type.
4343class 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)) {}

4353public:
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);
}
4371};

4373class TypedefType : public Type {
TypedefNameDecl *Decl;

4376private:
friend class ASTContext; // ASTContext creates these.

TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
            QualType can);

4382public:
TypedefNameDecl *getDecl() const { return Decl; }

bool isSugared() const { return true; }
QualType desugar() const;

static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389};

4391/// Sugar type that represents a type that was qualified by a qualifier written
4392/// as a macro invocation.
4393class 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) &&((void)0)
         "Expected a macro qualified type to only wrap attributed types.")((void)0);
}

4407public:
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;
}
4421};

4423/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424class TypeOfExprType : public Type {
Expr *TOExpr;

4427protected:
friend class ASTContext; // ASTContext creates these.

TypeOfExprType(Expr *E, QualType can = QualType());

4432public:
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; }
4442};

4444/// Internal representation of canonical, dependent
4445/// `typeof(expr)` types.
4446///
4447/// This class is used internally by the ASTContext to manage
4448/// canonical, dependent types, only. Clients will only see instances
4449/// of this class via TypeOfExprType nodes.
4450class DependentTypeOfExprType
: public TypeOfExprType, public llvm::FoldingSetNode {
const ASTContext &Context;

4454public:
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);
4464};

4466/// Represents `typeof(type)`, a GCC extension.
4467class 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")((void)0);
}

4477public:
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; }
4487};

4489/// Represents the type `decltype(expr)` (C++11).
4490class DecltypeType : public Type {
Expr *E;
QualType UnderlyingType;

4494protected:
friend class ASTContext; // ASTContext creates these.

DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());

4499public:
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; }
4510};

4512/// Internal representation of canonical, dependent
4513/// decltype(expr) types.
4514///
4515/// This class is used internally by the ASTContext to manage
4516/// canonical, dependent types, only. Clients will only see instances
4517/// of this class via DecltypeType nodes.
4518class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
const ASTContext &Context;

4521public:
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);
4530};

4532/// A unary type transform, which is a type constructed from another.
4533class UnaryTransformType : public Type {
4534public:
enum UTTKind {
  EnumUnderlyingType
};

4539private:
/// The untransformed type.
QualType BaseType;

/// The transformed type if not dependent, otherwise the same as BaseType.
QualType UnderlyingType;

UTTKind UKind;

4548protected:
friend class ASTContext;

UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
                   QualType CanonicalTy);

4554public:
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;
}
4566};

4568/// Internal representation of canonical, dependent
4569/// __underlying_type(type) types.
4570///
4571/// This class is used internally by the ASTContext to manage
4572/// canonical, dependent types, only. Clients will only see instances
4573/// of this class via UnaryTransformType nodes.
4574class DependentUnaryTransformType : public UnaryTransformType,
                                  public llvm::FoldingSetNode {
4576public:
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);
}
4589};

4591class 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;

4599protected:
TagType(TypeClass TC, const TagDecl *D, QualType can);

4602public:
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;
}
4611};

4613/// A helper class that allows the use of isa/cast/dyncast
4614/// to detect TagType objects of structs/unions/classes.
4615class RecordType : public TagType {
4616protected:
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()) {}

4624public:
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; }
4637};

4639/// A helper class that allows the use of isa/cast/dyncast
4640/// to detect TagType objects of enums.
4641class EnumType : public TagType {
friend class ASTContext; // ASTContext creates these.

explicit EnumType(const EnumDecl *D)
    : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}

4647public:
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; }
4656};

4658/// An attributed type is a type to which a type attribute has been applied.
4659///
4660/// The "modified type" is the fully-sugared type to which the attributed
4661/// type was applied; generally it is not canonically equivalent to the
4662/// attributed type. The "equivalent type" is the minimally-desugared type
4663/// which the type is canonically equivalent to.
4664///
4665/// For example, in the following attributed type:
4666///     int32_t __attribute__((vector_size(16)))
4667///   - the modified type is the TypedefType for int32_t
4668///   - the equivalent type is VectorType(16, int32_t)
4669///   - the canonical type is VectorType(16, int)
4670class AttributedType : public Type, public llvm::FoldingSetNode {
4671public:
using Kind = attr::Kind;

4674private:
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;
}

4687public:
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;
}
4765};

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

4807public:
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;
}
4837};

4839/// Represents the result of substituting a type for a template
4840/// type parameter.
4841///
4842/// Within an instantiated template, all template type parameters have
4843/// been replaced with these.  They are used solely to record that a
4844/// type was originally written as a template type parameter;
4845/// therefore they are never canonical.
4846class 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) {}

4856public:
/// 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;
}
4885};

4887/// Represents the result of substituting a set of types for a template
4888/// type parameter pack.
4889///
4890/// When a pack expansion in the source code contains multiple parameter packs
4891/// and those parameter packs correspond to different levels of template
4892/// parameter lists, this type node is used to represent a template type
4893/// parameter pack from an outer level, which has already had its argument pack
4894/// substituted but that still lives within a pack expansion that itself
4895/// could not be instantiated. When actually performing a substitution into
4896/// that pack expansion (e.g., when all template parameters have corresponding
4897/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898/// at the current pack substitution index.
4899class 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);

4913public:
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;
}
4938};

4940/// Common base class for placeholders for types that get replaced by
4941/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942/// class template types, and constrained type names.
4943///
4944/// These types are usually a placeholder for a deduced type. However, before
4945/// the initializer is attached, or (usually) if the initializer is
4946/// type-dependent, there is no deduced type and the type is canonical. In
4947/// the latter case, it is also a dependent type.
4948class DeducedType : public Type {
4949protected:
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)) {}

4961public:
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;
}
4978};

4980/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981/// by a type-constraint.
4982class 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);
}

4999public:
/// 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;
}
5045};

5047/// Represents a C++17 deduced template specialization type.
5048class 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) {}

5065public:
/// 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;
}
5083};

5085/// Represents a type template specialization; the template
5086/// must be a class template, a type alias template, or a template
5087/// template parameter.  A template which cannot be resolved to one of
5088/// these, e.g. because it is written with a dependent scope
5089/// specifier, is instead represented as a
5090/// @c DependentTemplateSpecializationType.
5091///
5092/// A non-dependent template specialization type is always "sugar",
5093/// typically for a \c RecordType.  For example, a class template
5094/// specialization type of \c vector<int> will refer to a tag type for
5095/// the instantiation \c std::vector<int, std::allocator<int>>
5096///
5097/// Template specializations are dependent if either the template or
5098/// any of the template arguments are dependent, in which case the
5099/// type may also be canonical.
5100///
5101/// Instances of this type are allocated with a trailing array of
5102/// TemplateArguments, followed by a QualType representing the
5103/// non-canonical aliased type when the template is a type alias
5104/// template.
5105class 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);

5124public:
/// 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")((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;
}
5222};

5224/// Print a template argument list, including the '<' and '>'
5225/// enclosing the template arguments.
5226void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgument> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5231void printTemplateArgumentList(raw_ostream &OS,
                             ArrayRef<TemplateArgumentLoc> Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5236void printTemplateArgumentList(raw_ostream &OS,
                             const TemplateArgumentListInfo &Args,
                             const PrintingPolicy &Policy,
                             const TemplateParameterList *TPL = nullptr);

5241/// The injected class name of a C++ class template or class
5242/// template partial specialization.  Used to record that a type was
5243/// spelled with a bare identifier rather than as a template-id; the
5244/// equivalent for non-templated classes is just RecordType.
5245///
5246/// Injected class name types are always dependent.  Template
5247/// instantiation turns these into RecordTypes.
5248///
5249/// Injected class name types are always canonical.  This works
5250/// because it is impossible to compare an injected class name type
5251/// with the corresponding non-injected template type, for the same
5252/// reason that it is impossible to directly compare template
5253/// parameters from different dependent contexts: injected class name
5254/// types can only occur within the scope of a particular templated
5255/// declaration, and within that scope every template specialization
5256/// will canonicalize to the injected class name (when appropriate
5257/// according to the rules of the language).
5258class 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))((void)0);
  assert(!TST.hasQualifiers())((void)0);
  assert(TST->isDependentType())((void)0);
}

5288public:
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;
}
5307};

5309/// The kind of a tag type.
5310enum 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
5325};

5327/// The elaboration keyword that precedes a qualified type name or
5328/// introduces an elaborated-type-specifier.
5329enum 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
5351};

5353/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354/// The keyword in stored in the free bits of the base class.
5355/// Also provides a few static helpers for converting and printing
5356/// elaborated type keyword and tag type kind enumerations.
5357class TypeWithKeyword : public Type {
5358protected:
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
                QualType Canonical, TypeDependence Dependence)
    : Type(tc, Canonical, Dependence) {
  TypeWithKeywordBits.Keyword = Keyword;
}

5365public:
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 *);
5395};

5397/// Represents a type that was referred to using an elaborated type
5398/// keyword, e.g., struct S, or via a qualified name, e.g., N::M::type,
5399/// or both.
5400///
5401/// This type is used to keep track of a type name as written in the
5402/// source code, including tag keywords and any nested-name-specifiers.
5403/// The type itself is always "sugar", used to express what was written
5404/// in the source code but containing no additional semantic information.
5405class 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) &&((void)0)
         "ElaboratedType cannot have elaborated type keyword "((void)0)
         "and name qualifier both null.")((void)0);
}

5444public:
/// 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; }
5478};

5480/// Represents a qualified type name for which the type name is
5481/// dependent.
5482///
5483/// DependentNameType represents a class of dependent types that involve a
5484/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
5485/// name of a type. The DependentNameType may start with a "typename" (for a
5486/// typename-specifier), "class", "struct", "union", or "enum" (for a
5487/// dependent elaborated-type-specifier), or nothing (in contexts where we
5488/// know that we must be referring to a type, e.g., in a base class specifier).
5489/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
5490/// mode, this type is used with non-dependent names to delay name lookup until
5491/// instantiation.
5492class 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) {}

5508public:
/// 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;
}
5538};

5540/// Represents a template specialization type whose template cannot be
5541/// resolved, e.g.
5542///   A<T>::template B<T>
5543class 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);
}

5568public:
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;
}
5610};

5612/// Represents a pack expansion of types.
5613///
5614/// Pack expansions are part of C++11 variadic templates. A pack
5615/// expansion contains a pattern, which itself contains one or more
5616/// "unexpanded" parameter packs. When instantiated, a pack expansion
5617/// produces a series of types, each instantiated from the pattern of
5618/// the expansion, where the Ith instantiation of the pattern uses the
5619/// Ith arguments bound to each of the unexpanded parameter packs. The
5620/// pack expansion is considered to "expand" these unexpanded
5621/// parameter packs.
5622///
5623/// \code
5624/// template<typename ...Types> struct tuple;
5625///
5626/// template<typename ...Types>
5627/// struct tuple_of_references {
5628///   typedef tuple<Types&...> type;
5629/// };
5630/// \endcode
5631///
5632/// Here, the pack expansion \c Types&... is represented via a
5633/// PackExpansionType whose pattern is Types&.
5634class 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;
}

5651public:
/// 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;
}
5683};

5685/// This class wraps the list of protocol qualifiers. For types that can
5686/// take ObjC protocol qualifers, they can subclass this class.
5687template <class T>
5688class ObjCProtocolQualifiers {
5689protected:
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() &&((void)0)
         "bitfield overflow in protocol count")((void)0);
  if (!protocols.empty())
    memcpy(getProtocolStorage(), protocols.data(),
           protocols.size() * sizeof(ObjCProtocolDecl*));
}

5713public:
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")((void)0);
  return qual_begin()[I];
}

/// Retrieve all of the protocol qualifiers.
ArrayRef<ObjCProtocolDecl *> getProtocols() const {
  return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
}
5739};

5741/// Represents a type parameter type in Objective C. It can take
5742/// a list of protocols.
5743class 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);

5773public:
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; }
5788};

5790/// Represents a class type in Objective C.
5791///
5792/// Every Objective C type is a combination of a base type, a set of
5793/// type arguments (optional, for parameterized classes) and a list of
5794/// protocols.
5795///
5796/// Given the following declarations:
5797/// \code
5798///   \@class C<T>;
5799///   \@protocol P;
5800/// \endcode
5801///
5802/// 'C' is an ObjCInterfaceType C.  It is sugar for an ObjCObjectType
5803/// with base C and no protocols.
5804///
5805/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
5806/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
5807/// protocol list.
5808/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
5809/// and protocol list [P].
5810///
5811/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
5812/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
5813/// and no protocols.
5814///
5815/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
5816/// with base BuiltinType::ObjCIdType and protocol list [P].  Eventually
5817/// this should get its own sugar class to better represent the source.
5818class 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;
}

5856protected:
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;

5874public:
/// 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?")((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;
}
5965};

5967/// A class providing a concrete implementation
5968/// of ObjCObjectType, so as to not increase the footprint of
5969/// ObjCInterfaceType.  Code outside of ASTContext and the core type
5970/// system should not reference this type.
5971class 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) {}

5983public:
void Profile(llvm::FoldingSetNodeID &ID);
static void Profile(llvm::FoldingSetNodeID &ID,
                    QualType Base,
                    ArrayRef<QualType> typeArgs,
                    ArrayRef<ObjCProtocolDecl *> protocols,
                    bool isKindOf);
5990};

5992inline QualType *ObjCObjectType::getTypeArgStorage() {
return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
5994}

5996inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
5999}

6001inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
  return reinterpret_cast<ObjCProtocolDecl**>(
           static_cast<ObjCTypeParamType*>(this)+1);
6004}

6006/// Interfaces are the core concept in Objective-C for object oriented design.
6007/// They basically correspond to C++ classes.  There are two kinds of interface
6008/// types: normal interfaces like `NSString`, and qualified interfaces, which
6009/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
6010///
6011/// ObjCInterfaceType guarantees the following properties when considered
6012/// as a subtype of its superclass, ObjCObjectType:
6013///   - There are no protocol qualifiers.  To reinforce this, code which
6014///     tries to invoke the protocol methods via an ObjCInterfaceType will
6015///     fail to compile.
6016///   - It is its own base type.  That is, if T is an ObjCInterfaceType*,
6017///     T->getBaseType() == QualType(T, 0).
6018class 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)) {}

6030public:
/// 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
};
6052};

6054inline 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;
6064}

6066/// Represents a pointer to an Objective C object.
6067///
6068/// These are constructed from pointer declarators when the pointee type is
6069/// an ObjCObjectType (or sugar for one).  In addition, the 'id' and 'Class'
6070/// types are typedefs for these, and the protocol-qualified types 'id<P>'
6071/// and 'Class<P>' are translated into these.
6072///
6073/// Pointers to pointers to Objective C objects are still PointerTypes;
6074/// only the first level of pointer gets it own type implementation.
6075class 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) {}

6084public:
/// 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;
}
6243};

6245class 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) {}

6253public:
/// 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;
}
6272};

6274/// PipeType - OpenCL20.
6275class 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) {}

6285public:
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; }
6306};

6308/// A fixed int type of a specified bitwidth.
6309class ExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
unsigned IsUnsigned : 1;
unsigned NumBits : 24;

6314protected:
ExtIntType(bool isUnsigned, unsigned NumBits);

6317public:
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; }
6336};

6338class DependentExtIntType final : public Type, public llvm::FoldingSetNode {
friend class ASTContext;
const ASTContext &Context;
llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;

6343protected:
DependentExtIntType(const ASTContext &Context, bool IsUnsigned,
                    Expr *NumBits);

6347public:
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;
}
6364};

6366/// A qualifier set is used to build a set of qualifiers.
6367class QualifierCollector : public Qualifiers {
6368public:
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;
6389};

6391/// A container of type source information.
6392///
6393/// A client can read the relevant info using TypeLoc wrappers, e.g:
6394/// @code
6395/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
6396/// TL.getBeginLoc().print(OS, SrcMgr);
6397/// @endcode
6398class 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) {}

6407public:
/// 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; }
6416};

6418// Inline function definitions.

6420inline SplitQualType SplitQualType::getSingleStepDesugaredType() const {
SplitQualType desugar =
  Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
desugar.Quals.addConsistentQualifiers(Quals);
return desugar;
6425}

6427inline const Type *QualType::getTypePtr() const {
return getCommonPtr()->BaseType;
6429}

6431inline const Type *QualType::getTypePtrOrNull() const {
return (isNull() ? nullptr : getCommonPtr()->BaseType);
6433}

6435inline 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);
6444}

6446inline Qualifiers QualType::getLocalQualifiers() const {
Qualifiers Quals;
if (hasLocalNonFastQualifiers())
  Quals = getExtQualsUnsafe()->getQualifiers();
Quals.addFastQualifiers(getLocalFastQualifiers());
return Quals;
6452}

6454inline Qualifiers QualType::getQualifiers() const {
Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
quals.addFastQualifiers(getLocalFastQualifiers());
return quals;
6458}

6460inline unsigned QualType::getCVRQualifiers() const {
unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
cvr |= getLocalCVRQualifiers();
return cvr;
6464}

6466inline QualType QualType::getCanonicalType() const {
QualType canon = getCommonPtr()->CanonicalType;
return canon.withFastQualifiers(getLocalFastQualifiers());
6469}

6471inline bool QualType::isCanonical() const {
return getTypePtr()->isCanonicalUnqualified();
6473}

6475inline 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);
6484}

6486inline bool QualType::isConstQualified() const {
return isLocalConstQualified() ||
       getCommonPtr()->CanonicalType.isLocalConstQualified();
6489}

6491inline bool QualType::isRestrictQualified() const {
return isLocalRestrictQualified() ||
       getCommonPtr()->CanonicalType.isLocalRestrictQualified();
6494}


6497inline bool QualType::isVolatileQualified() const {
return isLocalVolatileQualified() ||
       getCommonPtr()->CanonicalType.isLocalVolatileQualified();
6500}

6502inline bool QualType::hasQualifiers() const {
return hasLocalQualifiers() ||
       getCommonPtr()->CanonicalType.hasLocalQualifiers();
6505}

6507inline QualType QualType::getUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return QualType(getTypePtr(), 0);

return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
6512}

6514inline SplitQualType QualType::getSplitUnqualifiedType() const {
if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
  return split();

return getSplitUnqualifiedTypeImpl(*this);
6519}

6521inline void QualType::removeLocalConst() {
removeLocalFastQualifiers(Qualifiers::Const);
6523}

6525inline void QualType::removeLocalRestrict() {
removeLocalFastQualifiers(Qualifiers::Restrict);
6527}

6529inline void QualType::removeLocalVolatile() {
removeLocalFastQualifiers(Qualifiers::Volatile);
6531}

6533inline void QualType::removeLocalCVRQualifiers(unsigned Mask) {
assert(!(Mask & ~Qualifiers::CVRMask) && "mask has non-CVR bits")((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);
6540}

6542/// Check if this type has any address space qualifier.
6543inline bool QualType::hasAddressSpace() const {
return getQualifiers().hasAddressSpace();
6545}

6547/// Return the address space of this type.
6548inline LangAS QualType::getAddressSpace() const {
return getQualifiers().getAddressSpace();
6550}

6552/// Return the gc attribute of this type.
6553inline Qualifiers::GC QualType::getObjCGCAttr() const {
return getQualifiers().getObjCGCAttr();
6555}

6557inline bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDefaultInitializeCUnion(RD);
return false;
6561}

6563inline bool QualType::hasNonTrivialToPrimitiveDestructCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveDestructCUnion(RD);
return false;
6567}

6569inline bool QualType::hasNonTrivialToPrimitiveCopyCUnion() const {
if (auto *RD = getTypePtr()->getBaseElementTypeUnsafe()->getAsRecordDecl())
  return hasNonTrivialToPrimitiveCopyCUnion(RD);
return false;
6573}

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

6585inline FunctionType::ExtInfo getFunctionExtInfo(QualType t) {
return getFunctionExtInfo(*t);
6587}

6589/// Determine whether this type is more
6590/// qualified than the Other type. For example, "const volatile int"
6591/// is more qualified than "const int", "volatile int", and
6592/// "int". However, it is not more qualified than "const volatile
6593/// int".
6594inline bool QualType::isMoreQualifiedThan(QualType other) const {
Qualifiers MyQuals = getQualifiers();
Qualifiers OtherQuals = other.getQualifiers();
return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals));
6598}

6600/// Determine whether this type is at last
6601/// as qualified as the Other type. For example, "const volatile
6602/// int" is at least as qualified as "const int", "volatile int",
6603/// "int", and "const volatile int".
6604inline 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);
6612}

6614/// If Type is a reference type (e.g., const
6615/// int&), returns the type that the reference refers to ("const
6616/// int"). Otherwise, returns the type itself. This routine is used
6617/// throughout Sema to implement C++ 5p6:
6618///
6619///   If an expression initially has the type "reference to T" (8.3.2,
6620///   8.5.3), the type is adjusted to "T" prior to any further
6621///   analysis, the expression designates the object or function
6622///   denoted by the reference, and the expression is an lvalue.
6623inline QualType QualType::getNonReferenceType() const {
if (const auto *RefType = (*this)->getAs<ReferenceType>())
  return RefType->getPointeeType();
else
  return *this;
6628}

6630inline bool QualType::isCForbiddenLValueType() const {
return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
        getTypePtr()->isFunctionType());
6633}

6635/// Tests whether the type is categorized as a fundamental type.
6636///
6637/// \returns True for types specified in C++0x [basic.fundamental].
6638inline 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());
6644}

6646/// Tests whether the type is categorized as a compound type.
6647///
6648/// \returns True for types specified in C++0x [basic.compound].
6649inline 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();
6669}

6671inline bool Type::isFunctionType() const {
return isa<FunctionType>(CanonicalType);
6673}

6675inline bool Type::isPointerType() const {
return isa<PointerType>(CanonicalType);
6677}

6679inline bool Type::isAnyPointerType() const {
return isPointerType() || isObjCObjectPointerType();
6681}

6683inline bool Type::isBlockPointerType() const {
return isa<BlockPointerType>(CanonicalType);
6685}

6687inline bool Type::isReferenceType() const {
return isa<ReferenceType>(CanonicalType);
6689}

6691inline bool Type::isLValueReferenceType() const {
return isa<LValueReferenceType>(CanonicalType);
6693}

6695inline bool Type::isRValueReferenceType() const {
return isa<RValueReferenceType>(CanonicalType);
6697}

6699inline 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;
6707}

6709inline bool Type::isFunctionPointerType() const {
if (const auto *T = getAs<PointerType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6714}

6716inline bool Type::isFunctionReferenceType() const {
if (const auto *T = getAs<ReferenceType>())
  return T->getPointeeType()->isFunctionType();
else
  return false;
6721}

6723inline bool Type::isMemberPointerType() const {
return isa<MemberPointerType>(CanonicalType);
6725}

6727inline bool Type::isMemberFunctionPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberFunctionPointer();
else
  return false;
6732}

6734inline bool Type::isMemberDataPointerType() const {
if (const auto *T = getAs<MemberPointerType>())
  return T->isMemberDataPointer();
else
  return false;
6739}

6741inline bool Type::isArrayType() const {
return isa<ArrayType>(CanonicalType);
6743}

6745inline bool Type::isConstantArrayType() const {
return isa<ConstantArrayType>(CanonicalType);
6747}

6749inline bool Type::isIncompleteArrayType() const {
return isa<IncompleteArrayType>(CanonicalType);
6751}

6753inline bool Type::isVariableArrayType() const {
return isa<VariableArrayType>(CanonicalType);
6755}

6757inline bool Type::isDependentSizedArrayType() const {
return isa<DependentSizedArrayType>(CanonicalType);
6759}

6761inline bool Type::isBuiltinType() const {
return isa<BuiltinType>(CanonicalType);
6763}

6765inline bool Type::isRecordType() const {
return isa<RecordType>(CanonicalType);
6767}

6769inline bool Type::isEnumeralType() const {
return isa<EnumType>(CanonicalType);
6771}

6773inline bool Type::isAnyComplexType() const {
return isa<ComplexType>(CanonicalType);
6775}

6777inline bool Type::isVectorType() const {
return isa<VectorType>(CanonicalType);
6779}

6781inline bool Type::isExtVectorType() const {
return isa<ExtVectorType>(CanonicalType);
6783}

6785inline bool Type::isMatrixType() const {
return isa<MatrixType>(CanonicalType);
4
←
Assuming field 'CanonicalType' is a 'MatrixType'→
5
←
Returning the value 1, which participates in a condition later→
8
←
Assuming field 'CanonicalType' is a 'MatrixType'→
9
←
Returning the value 1, which participates in a condition later→
6787}

6789inline bool Type::isConstantMatrixType() const {
return isa<ConstantMatrixType>(CanonicalType);
6791}

6793inline bool Type::isDependentAddressSpaceType() const {
return isa<DependentAddressSpaceType>(CanonicalType);
6795}

6797inline bool Type::isObjCObjectPointerType() const {
return isa<ObjCObjectPointerType>(CanonicalType);
6799}

6801inline bool Type::isObjCObjectType() const {
return isa<ObjCObjectType>(CanonicalType);
6803}

6805inline bool Type::isObjCObjectOrInterfaceType() const {
return isa<ObjCInterfaceType>(CanonicalType) ||
  isa<ObjCObjectType>(CanonicalType);
6808}

6810inline bool Type::isAtomicType() const {
return isa<AtomicType>(CanonicalType);
6812}

6814inline bool Type::isUndeducedAutoType() const {
return isa<AutoType>(CanonicalType);
6816}

6818inline bool Type::isObjCQualifiedIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedIdType();
return false;
6822}

6824inline bool Type::isObjCQualifiedClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCQualifiedClassType();
return false;
6828}

6830inline bool Type::isObjCIdType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCIdType();
return false;
6834}

6836inline bool Type::isObjCClassType() const {
if (const auto *OPT = getAs<ObjCObjectPointerType>())
  return OPT->isObjCClassType();
return false;
6840}

6842inline bool Type::isObjCSelType() const {
if (const auto *OPT = getAs<PointerType>())
  return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
return false;
6846}

6848inline bool Type::isObjCBuiltinType() const {
return isObjCIdType() || isObjCClassType() || isObjCSelType();
6850}

6852inline bool Type::isDecltypeType() const {
return isa<DecltypeType>(this);
6854}

6856#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6860#include "clang/Basic/OpenCLImageTypes.def"

6862inline bool Type::isSamplerT() const {
return isSpecificBuiltinType(BuiltinType::OCLSampler);
6864}

6866inline bool Type::isEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLEvent);
6868}

6870inline bool Type::isClkEventT() const {
return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
6872}

6874inline bool Type::isQueueT() const {
return isSpecificBuiltinType(BuiltinType::OCLQueue);
6876}

6878inline bool Type::isReserveIDT() const {
return isSpecificBuiltinType(BuiltinType::OCLReserveID);
6880}

6882inline bool Type::isImageType() const {
6883#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
return
6885#include "clang/Basic/OpenCLImageTypes.def"
    false; // end boolean or operation
6887}

6889inline bool Type::isPipeType() const {
return isa<PipeType>(CanonicalType);
6891}

6893inline bool Type::isExtIntType() const {
return isa<ExtIntType>(CanonicalType);
6895}

6897#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
inline bool Type::is##Id##Type() const { \
  return isSpecificBuiltinType(BuiltinType::Id); \
}
6901#include "clang/Basic/OpenCLExtensionTypes.def"

6903inline bool Type::isOCLIntelSubgroupAVCType() const {
6904#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
isOCLIntelSubgroupAVC##Id##Type() ||
return
6907#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6909}

6911inline bool Type::isOCLExtOpaqueType() const {
6912#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
return
6914#include "clang/Basic/OpenCLExtensionTypes.def"
  false; // end of boolean or operation
6916}

6918inline bool Type::isOpenCLSpecificType() const {
return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
       isQueueT() || isReserveIDT() || isPipeType() || isOCLExtOpaqueType();
6921}

6923inline bool Type::isTemplateTypeParmType() const {
return isa<TemplateTypeParmType>(CanonicalType);
6925}

6927inline bool Type::isSpecificBuiltinType(unsigned K) const {
if (const BuiltinType *BT = getAs<BuiltinType>()) {
  return BT->getKind() == static_cast<BuiltinType::Kind>(K);
}
return false;
6932}

6934inline bool Type::isPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isPlaceholderType();
return false;
6938}

6940inline const BuiltinType *Type::getAsPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  if (BT->isPlaceholderType())
    return BT;
return nullptr;
6945}

6947inline bool Type::isSpecificPlaceholderType(unsigned K) const {
assert(BuiltinType::isPlaceholderTypeKind((BuiltinType::Kind) K))((void)0);
return isSpecificBuiltinType(K);
6950}

6952inline bool Type::isNonOverloadPlaceholderType() const {
if (const auto *BT = dyn_cast<BuiltinType>(this))
  return BT->isNonOverloadPlaceholderType();
return false;
6956}

6958inline bool Type::isVoidType() const {
return isSpecificBuiltinType(BuiltinType::Void);
6960}

6962inline bool Type::isHalfType() const {
// FIXME: Should we allow complex __fp16? Probably not.
return isSpecificBuiltinType(BuiltinType::Half);
6965}

6967inline bool Type::isFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::Float16);
6969}

6971inline bool Type::isBFloat16Type() const {
return isSpecificBuiltinType(BuiltinType::BFloat16);
6973}

6975inline bool Type::isFloat128Type() const {
return isSpecificBuiltinType(BuiltinType::Float128);
6977}

6979inline bool Type::isNullPtrType() const {
return isSpecificBuiltinType(BuiltinType::NullPtr);
6981}

6983bool IsEnumDeclComplete(EnumDecl *);
6984bool IsEnumDeclScoped(EnumDecl *);

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

6999inline bool Type::isFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::ShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7005}

7007inline bool Type::isFixedPointOrIntegerType() const {
return isFixedPointType() || isIntegerType();
7009}

7011inline bool Type::isSaturatedFixedPointType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
  return BT->getKind() >= BuiltinType::SatShortAccum &&
         BT->getKind() <= BuiltinType::SatULongFract;
}
return false;
7017}

7019inline bool Type::isUnsaturatedFixedPointType() const {
return isFixedPointType() && !isSaturatedFixedPointType();
7021}

7023inline 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;
7035}

7037inline bool Type::isUnsignedFixedPointType() const {
return isFixedPointType() && !isSignedFixedPointType();
7039}

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

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

7070inline bool Type::isBooleanType() const {
if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
  return BT->getKind() == BuiltinType::Bool;
return false;
7074}

7076inline bool Type::isUndeducedType() const {
auto *DT = getContainedDeducedType();
return DT && !DT->isDeduced();
7079}

7081/// Determines whether this is a type for which one can define
7082/// an overloaded operator.
7083inline bool Type::isOverloadableType() const {
return isDependentType() || isRecordType() || isEnumeralType();
7085}

7087/// Determines whether this type is written as a typedef-name.
7088inline bool Type::isTypedefNameType() const {
if (getAs<TypedefType>())
  return true;
if (auto *TST = getAs<TemplateSpecializationType>())
  return TST->isTypeAlias();
return false;
7094}

7096/// Determines whether this type can decay to a pointer type.
7097inline bool Type::canDecayToPointerType() const {
return isFunctionType() || isArrayType();
7099}

7101inline bool Type::hasPointerRepresentation() const {
return (isPointerType() || isReferenceType() || isBlockPointerType() ||
        isObjCObjectPointerType() || isNullPtrType());
7104}

7106inline bool Type::hasObjCPointerRepresentation() const {
return isObjCObjectPointerType();
7108}

7110inline const Type *Type::getBaseElementTypeUnsafe() const {
const Type *type = this;
while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
  type = arrayType->getElementType().getTypePtr();
return type;
7115}

7117inline 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;
7124}
7125/// Insertion operator for partial diagnostics. This allows sending adress
7126/// spaces into a diagnostic with <<.
7127inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           LangAS AS) {
PD.AddTaggedVal(static_cast<std::underlying_type_t<LangAS>>(AS),
                DiagnosticsEngine::ArgumentKind::ak_addrspace);
return PD;
7132}

7134/// Insertion operator for partial diagnostics. This allows sending Qualifiers
7135/// into a diagnostic with <<.
7136inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           Qualifiers Q) {
PD.AddTaggedVal(Q.getAsOpaqueValue(),
                DiagnosticsEngine::ArgumentKind::ak_qual);
return PD;
7141}

7143/// Insertion operator for partial diagnostics.  This allows sending QualType's
7144/// into a diagnostic with <<.
7145inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,
                                           QualType T) {
PD.AddTaggedVal(reinterpret_cast<intptr_t>(T.getAsOpaquePtr()),
                DiagnosticsEngine::ak_qualtype);
return PD;
7150}

7152// Helper class template that is used by Type::getAs to ensure that one does
7153// not try to look through a qualified type to get to an array type.
7154template <typename T>
7155using TypeIsArrayType =
  std::integral_constant<bool, std::is_same<T, ArrayType>::value ||
                                   std::is_base_of<ArrayType, T>::value>;

7159// Member-template getAs<specific type>'.
7160template <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());
7175}

7177template <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);
7209}

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

7225template <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))((void)0);
return cast<T>(getUnqualifiedDesugaredType());
7232}

7234inline const ArrayType *Type::castAsArrayTypeUnsafe() const {
assert(isa<ArrayType>(CanonicalType))((void)0);
if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
return cast<ArrayType>(getUnqualifiedDesugaredType());
7238}

7240DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
                       QualType CanonicalPtr)
  : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
7243#ifndef NDEBUG1
QualType Adjusted = getAdjustedType();
(void)AttributedType::stripOuterNullability(Adjusted);
assert(isa<PointerType>(Adjusted))((void)0);
7247#endif
7248}

7250QualType DecayedType::getPointeeType() const {
QualType Decayed = getDecayedType();
(void)AttributedType::stripOuterNullability(Decayed);
return cast<PointerType>(Decayed)->getPointeeType();
7254}

7256// Get the decimal string representation of a fixed point type, represented
7257// as a scaled integer.
7258// TODO: At some point, we should change the arguments to instead just accept an
7259// APFixedPoint instead of APSInt and scale.
7260void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
                           unsigned Scale);

7263} // namespace clang

7265#endif // LLVM_CLANG_AST_TYPE_H