/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp

Bug Summary

File:	clang/lib/Sema/SemaExpr.cpp
Warning:	line 4842, column 18 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaExpr.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-13-084841-49055-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp
/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/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 "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTLambda.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/CXXInheritance.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/EvaluatedExprVisitor.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/ExprOpenMP.h"
26#include "clang/AST/RecursiveASTVisitor.h"
27#include "clang/AST/TypeLoc.h"
28#include "clang/Basic/Builtins.h"
29#include "clang/Basic/FixedPoint.h"
30#include "clang/Basic/PartialDiagnostic.h"
31#include "clang/Basic/SourceManager.h"
32#include "clang/Basic/TargetInfo.h"
33#include "clang/Lex/LiteralSupport.h"
34#include "clang/Lex/Preprocessor.h"
35#include "clang/Sema/AnalysisBasedWarnings.h"
36#include "clang/Sema/DeclSpec.h"
37#include "clang/Sema/DelayedDiagnostic.h"
38#include "clang/Sema/Designator.h"
39#include "clang/Sema/Initialization.h"
40#include "clang/Sema/Lookup.h"
41#include "clang/Sema/Overload.h"
42#include "clang/Sema/ParsedTemplate.h"
43#include "clang/Sema/Scope.h"
44#include "clang/Sema/ScopeInfo.h"
45#include "clang/Sema/SemaFixItUtils.h"
46#include "clang/Sema/SemaInternal.h"
47#include "clang/Sema/Template.h"
48#include "llvm/Support/ConvertUTF.h"
49using namespace clang;
50using namespace sema;

52/// Determine whether the use of this declaration is valid, without
53/// emitting diagnostics.
54bool 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;

return true;
83}

85static 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->getDeclName();
  }
}
97}

99/// Emit a note explaining that this function is deleted.
100void Sema::NoteDeletedFunction(FunctionDecl *Decl) {
assert(Decl && Decl->isDeleted())((Decl && Decl->isDeleted()) ? static_cast<void
> (0) : __assert_fail ("Decl && Decl->isDeleted()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 101, __PRETTY_FUNCTION__));

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

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

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

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

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

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

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

195/// Determine whether the use of this declaration is valid, and
196/// emit any corresponding diagnostics.
197///
198/// This routine diagnoses various problems with referencing
199/// declarations that can occur when using a declaration. For example,
200/// it might warn if a deprecated or unavailable declaration is being
201/// used, or produce an error (and return true) if a C++0x deleted
202/// function is being used.
203///
204/// \returns true if there was an error (this declaration cannot be
205/// referenced), false otherwise.
206///
207bool 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;
}

// See if this is a deleted function.
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  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;
  }

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

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

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

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

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

// [OpenMP 5.0], 2.19.7.3. declare mapper Directive, Restrictions
//  List-items in map clauses on this construct may only refer to the declared
//  variable var and entities that could be referenced by a procedure defined
//  at the same location
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(CurContext);
if (LangOpts.OpenMP && DMD && !CurContext->containsDecl(D) &&
    isa<VarDecl>(D)) {
  Diag(Loc, diag::err_omp_declare_mapper_wrong_var)
      << DMD->getVarName().getAsString();
  Diag(D->getLocation(), diag::note_entity_declared_at) << D;
  return true;
}

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

DiagnoseUnusedOfDecl(*this, D, Loc);

diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);

// [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.
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  if (Expr *RC = FD->getTrailingRequiresClause()) {
    ConstraintSatisfaction Satisfaction;
    bool Failed = CheckConstraintSatisfaction(RC, Satisfaction);
    if (Failed)
      // 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;
    }
  }
}

return false;
354}

356/// DiagnoseSentinelCalls - This routine checks whether a call or
357/// message-send is to a declaration with the sentinel attribute, and
358/// if so, it checks that the requirements of the sentinel are
359/// satisfied.
360void 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")(((nullPos == 0 || nullPos == 1) && "invalid null position on sentinel"
) ? static_cast<void> (0) : __assert_fail ("(nullPos == 0 || nullPos == 1) && \"invalid null position on sentinel\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 407, __PRETTY_FUNCTION__));
numFormalParams = (nullPos > numFormalParams ? 0 : numFormalParams - nullPos);

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

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

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

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

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

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

455//===----------------------------------------------------------------------===//
456//  Standard Promotions and Conversions
457//===----------------------------------------------------------------------===//

459/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
460ExprResult 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")((!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"DefaultFunctionArrayConversion - missing type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 469, __PRETTY_FUNCTION__));

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

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

498static 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));
  }
}
521}

523static 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);
    }
  }
578}

580ExprResult 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?")((!T.isNull() && "r-value conversion on typeless expression?"
) ? static_cast<void> (0) : __assert_fail ("!T.isNull() && \"r-value conversion on typeless expression?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 594, __PRETTY_FUNCTION__));

// 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().isEnabled("cl_khr_fp16") &&
    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);

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

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

return Res;
679}

681ExprResult 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;
689}

691/// CallExprUnaryConversions - a special case of an unary conversion
692/// performed on a function designator of a call expression.
693ExprResult 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).get();
  if (Res.isInvalid())
    return ExprError();
}
Res = DefaultLvalueConversion(Res.get());
if (Res.isInvalid())
  return ExprError();
return Res.get();
708}

710/// UsualUnaryConversions - Performs various conversions that are common to most
711/// operators (C99 6.3). The conversions of array and function types are
712/// sometimes suppressed. For example, the array->pointer conversion doesn't
713/// apply if the array is an argument to the sizeof or address (&) operators.
714/// In these instances, this routine should *not* be called.
715ExprResult 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")((!Ty.isNull() && "UsualUnaryConversions - missing type"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"UsualUnaryConversions - missing type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 723, __PRETTY_FUNCTION__));

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

760/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
761/// do not have a prototype. Arguments that have type float or __fp16
762/// are promoted to double. All other argument types are converted by
763/// UsualUnaryConversions().
764ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
QualType Ty = E->getType();
assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type")((!Ty.isNull() && "DefaultArgumentPromotion - missing type"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"DefaultArgumentPromotion - missing type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 766, __PRETTY_FUNCTION__));

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

// If this is a 'float'  or '__fp16' (CVR qualified or typedef)
// promote to double.
// Note that default argument promotion applies only to float (and
// half/fp16); it does not apply to _Float16.
const BuiltinType *BTy = Ty->getAs<BuiltinType>();
if (BTy && (BTy->getKind() == BuiltinType::Half ||
            BTy->getKind() == BuiltinType::Float)) {
  if (getLangOpts().OpenCL &&
      !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
      if (BTy->getKind() == BuiltinType::Half) {
          E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
      }
  } else {
    E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
  }
}

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

813/// Determine the degree of POD-ness for an expression.
814/// Incomplete types are considered POD, since this check can be performed
815/// when we're in an unevaluated context.
816Sema::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;
864}

866void 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;
}
909}

911/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
912/// will create a trap if the resulting type is not a POD type.
913ExprResult 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();
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;
969}

971/// Converts an integer to complex float type.  Helper function of
972/// UsualArithmeticConversions()
973///
974/// \return false if the integer expression is an integer type and is
975/// successfully converted to the complex type.
976static 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())((IntTy->isComplexIntegerType()) ? static_cast<void>
 (0) : __assert_fail ("IntTy->isComplexIntegerType()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 989, __PRETTY_FUNCTION__));
  IntExpr = S.ImpCastExprToType(IntExpr.get(), ComplexTy,
                                CK_IntegralComplexToFloatingComplex);
}
return false;
994}

996/// Handle arithmetic conversion with complex types.  Helper function of
997/// UsualArithmeticConversions()
998static 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;
1050}

1052/// Handle arithmetic conversion from integer to float.  Helper function
1053/// of UsualArithmeticConversions()
1054static 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())((IntTy->isComplexIntegerType()) ? static_cast<void>
 (0) : __assert_fail ("IntTy->isComplexIntegerType()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1067, __PRETTY_FUNCTION__));
QualType result = S.Context.getComplexType(FloatTy);

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

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

return result;
1081}

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

// 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")((order < 0 && "illegal float comparison") ? static_cast
<void> (0) : __assert_fail ("order < 0 && \"illegal float comparison\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1100, __PRETTY_FUNCTION__));
  if (!IsCompAssign)
    LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
  return RHSType;
}

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

  return handleIntToFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                    /*ConvertFloat=*/!IsCompAssign,
                                    /*ConvertInt=*/ true);
}
assert(RHSFloat)((RHSFloat) ? static_cast<void> (0) : __assert_fail ("RHSFloat"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1115, __PRETTY_FUNCTION__));
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                  /*convertInt=*/ true,
                                  /*convertFloat=*/!IsCompAssign);
1119}

1121/// Diagnose attempts to convert between __float128 and long double if
1122/// there is no support for such conversion. Helper function of
1123/// UsualArithmeticConversions().
1124static 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() &&((LHSType->isFloatingType() && RHSType->isFloatingType
() && "The remaining types must be floating point types."
) ? static_cast<void> (0) : __assert_fail ("LHSType->isFloatingType() && RHSType->isFloatingType() && \"The remaining types must be floating point types.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1134, __PRETTY_FUNCTION__))
       "The remaining types must be floating point types.")((LHSType->isFloatingType() && RHSType->isFloatingType
() && "The remaining types must be floating point types."
) ? static_cast<void> (0) : __assert_fail ("LHSType->isFloatingType() && RHSType->isFloatingType() && \"The remaining types must be floating point types.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1134, __PRETTY_FUNCTION__));

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

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

1164namespace {
1165/// These helper callbacks are placed in an anonymous namespace to
1166/// permit their use as function template parameters.
1167ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, toType, CK_IntegralCast);
1169}

1171ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
                           CK_IntegralComplexCast);
1174}
1175}

1177/// Handle integer arithmetic conversions.  Helper function of
1178/// UsualArithmeticConversions()
1179template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
1180static 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;
}
1226}

1228/// Handle conversions with GCC complex int extension.  Helper function
1229/// of UsualArithmeticConversions()
1230static 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)((RHSComplexInt) ? static_cast<void> (0) : __assert_fail
 ("RHSComplexInt", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1259, __PRETTY_FUNCTION__));

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

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

1273/// Return the rank of a given fixed point or integer type. The value itself
1274/// doesn't matter, but the values must be increasing with proper increasing
1275/// rank as described in N1169 4.1.1.
1276static unsigned GetFixedPointRank(QualType Ty) {
const auto *BTy = Ty->getAs<BuiltinType>();
assert(BTy && "Expected a builtin type.")((BTy && "Expected a builtin type.") ? static_cast<
void> (0) : __assert_fail ("BTy && \"Expected a builtin type.\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1278, __PRETTY_FUNCTION__));

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

1318/// handleFixedPointConversion - Fixed point operations between fixed
1319/// point types and integers or other fixed point types do not fall under
1320/// usual arithmetic conversion since these conversions could result in loss
1321/// of precsision (N1169 4.1.4). These operations should be calculated with
1322/// the full precision of their result type (N1169 4.1.6.2.1).
1323static QualType handleFixedPointConversion(Sema &S, QualType LHSTy,
                                         QualType RHSTy) {
assert((LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) &&(((LHSTy->isFixedPointType() || RHSTy->isFixedPointType
()) && "Expected at least one of the operands to be a fixed point type"
) ? static_cast<void> (0) : __assert_fail ("(LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) && \"Expected at least one of the operands to be a fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1326, __PRETTY_FUNCTION__))
       "Expected at least one of the operands to be a fixed point type")(((LHSTy->isFixedPointType() || RHSTy->isFixedPointType
()) && "Expected at least one of the operands to be a fixed point type"
) ? static_cast<void> (0) : __assert_fail ("(LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) && \"Expected at least one of the operands to be a fixed point type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1326, __PRETTY_FUNCTION__));
assert((LHSTy->isFixedPointOrIntegerType() ||(((LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType
()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? static_cast<
void> (0) : __assert_fail ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1330, __PRETTY_FUNCTION__))
        RHSTy->isFixedPointOrIntegerType()) &&(((LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType
()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? static_cast<
void> (0) : __assert_fail ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1330, __PRETTY_FUNCTION__))
       "Special fixed point arithmetic operation conversions are only "(((LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType
()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? static_cast<
void> (0) : __assert_fail ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1330, __PRETTY_FUNCTION__))
       "applied to ints or other fixed point types")(((LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType
()) && "Special fixed point arithmetic operation conversions are only "
 "applied to ints or other fixed point types") ? static_cast<
void> (0) : __assert_fail ("(LHSTy->isFixedPointOrIntegerType() || RHSTy->isFixedPointOrIntegerType()) && \"Special fixed point arithmetic operation conversions are only \" \"applied to ints or other fixed point types\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1330, __PRETTY_FUNCTION__));

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

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

QualType ResultTy = LHSTyRank > RHSTyRank ? LHSTy : RHSTy;

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

return ResultTy;
1358}

1360/// Check that the usual arithmetic conversions can be performed on this pair of
1361/// expressions that might be of enumeration type.
1362static 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().CPlusPlus2a
                  ? diag::warn_arith_conv_enum_float_cxx2a
                  : 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().CPlusPlus2a
                  ? diag::warn_arith_conv_mixed_anon_enum_types_cxx2a
                  : 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().CPlusPlus2a
                 ? diag::warn_conditional_mixed_enum_types_cxx2a
                 : 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().CPlusPlus2a
                 ? diag::warn_comparison_mixed_enum_types_cxx2a
                 : diag::warn_comparison_mixed_enum_types;
  } else {
    DiagID = S.getLangOpts().CPlusPlus2a
                 ? diag::warn_arith_conv_mixed_enum_types_cxx2a
                 : diag::warn_arith_conv_mixed_enum_types;
  }
  S.Diag(Loc, DiagID) << LHS->getSourceRange() << RHS->getSourceRange()
                      << (int)ACK << L << R;
}
1414}

1416/// UsualArithmeticConversions - Performs various conversions that are common to
1417/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this
1418/// routine returns the first non-arithmetic type found. The client is
1419/// responsible for emitting appropriate error diagnostics.
1420QualType 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);
1497}

1499//===----------------------------------------------------------------------===//
1500//  Semantic Analysis for various Expression Types
1501//===----------------------------------------------------------------------===//


1504ExprResult
1505Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                              SourceLocation DefaultLoc,
                              SourceLocation RParenLoc,
                              Expr *ControllingExpr,
                              ArrayRef<ParsedType> ArgTypes,
                              ArrayRef<Expr *> ArgExprs) {
unsigned NumAssocs = ArgTypes.size();
assert(NumAssocs == ArgExprs.size())((NumAssocs == ArgExprs.size()) ? static_cast<void> (0)
 : __assert_fail ("NumAssocs == ArgExprs.size()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1512, __PRETTY_FUNCTION__));

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

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

1530ExprResult
1531Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc,
                               SourceLocation DefaultLoc,
                               SourceLocation RParenLoc,
                               Expr *ControllingExpr,
                               ArrayRef<TypeSourceInfo *> Types,
                               ArrayRef<Expr *> Exprs) {
unsigned NumAssocs = Types.size();
assert(NumAssocs == Exprs.size())((NumAssocs == Exprs.size()) ? static_cast<void> (0) : __assert_fail
 ("NumAssocs == Exprs.size()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1538, __PRETTY_FUNCTION__));

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

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

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

1683/// BuildCookedLiteralOperatorCall - A user-defined literal was found. Look up
1684/// the corresponding cooked (non-raw) literal operator, and build a call to it.
1685static 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")((Args.size() <= 2 && "too many arguments for literal operator"
) ? static_cast<void> (0) : __assert_fail ("Args.size() <= 2 && \"too many arguments for literal operator\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1690, __PRETTY_FUNCTION__));

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

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

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

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

1714/// ActOnStringLiteral - The specified tokens were lexed as pasted string
1715/// fragments (e.g. "foo" "bar" L"baz").  The result string has to handle string
1716/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1717/// multiple tokens.  However, the common case is that StringToks points to one
1718/// string.
1719///
1720ExprResult
1721Sema::ActOnStringLiteral(ArrayRef<Token> StringToks, Scope *UDLScope) {
assert(!StringToks.empty() && "Must have at least one string!")((!StringToks.empty() && "Must have at least one string!"
) ? static_cast<void> (0) : __assert_fail ("!StringToks.empty() && \"Must have at least one string!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1722, __PRETTY_FUNCTION__));

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

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

QualType CharTy = Context.CharTy;
StringLiteral::StringKind Kind = StringLiteral::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().CPlusPlus2a &&
    !getLangOpts().Char8 && Kind == StringLiteral::UTF8) {
  Diag(StringTokLocs.front(), diag::warn_cxx2a_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_cxx2a_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*/ false,
                              /*AllowStringTemplate*/ true,
                              /*DiagnoseMissing*/ true)) {

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_StringTemplate: {
  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_Template:
case LOLR_ErrorNoDiagnostic:
  llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1848);
case LOLR_Error:
  return ExprError();
}
llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 1852);
1853}

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

1863DeclRefExpr *
1864Sema::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);
1873}

1875NonOdrUseReason 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.
if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
  if (VD->getType()->isReferenceType() &&
      !(getLangOpts().OpenMP && isOpenMPCapturedDecl(D)) &&
      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;
1894}

1896/// BuildDeclRefExpr - Build an expression that references a
1897/// declaration that does not require a closure capture.
1898DeclRefExpr *
1899Sema::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;
1954}

1956/// Decomposes the given name into a DeclarationNameInfo, its location, and
1957/// possibly a list of template arguments.
1958///
1959/// If this produces template arguments, it is permitted to call
1960/// DecomposeTemplateName.
1961///
1962/// This actually loses a lot of source location information for
1963/// non-standard name kinds; we should consider preserving that in
1964/// some way.
1965void
1966Sema::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;
}
1986}

1988static 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));
2019}

2021/// Diagnose an empty lookup.
2022///
2023/// \return false if new lookup candidates were found
2024bool 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();

      // 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() &&
                        DC == CurMethod->getParent() && !isDefaultArgument;

      // Give a code modification hint to insert 'this->'.
      // TODO: fixit for inserting 'Base<T>::' in the other cases.
      // Actually quite difficult!
      if (getLangOpts().MSVCCompat)
        diagnostic = diag::ext_found_via_dependent_bases_lookup;
      if (isInstance) {
        Diag(R.getNameLoc(), diagnostic) << Name
          << FixItHint::CreateInsertion(R.getNameLoc(), "this->");
        CheckCXXThisCapture(R.getNameLoc());
      } else {
        Diag(R.getNameLoc(), diagnostic) << Name;
      }

      // Do we really want to note all of these?
      for (NamedDecl *D : R)
        Diag(D->getLocation(), diag::note_dependent_var_use);

      // Return true if we are inside a default argument instantiation
      // and the found name refers to an instance member function, otherwise
      // the function calling DiagnoseEmptyLookup will try to create an
      // implicit member call and this is wrong for default argument.
      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;
    }

    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 &&((!ExplicitTemplateArgs && "Diagnosing an empty lookup with explicit template args!"
) ? static_cast<void> (0) : __assert_fail ("!ExplicitTemplateArgs && \"Diagnosing an empty lookup with explicit template args!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2105, __PRETTY_FUNCTION__))
         "Diagnosing an empty lookup with explicit template args!")((!ExplicitTemplateArgs && "Diagnosing an empty lookup with explicit template args!"
) ? static_cast<void> (0) : __assert_fail ("!ExplicitTemplateArgs && \"Diagnosing an empty lookup with explicit template args!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2105, __PRETTY_FUNCTION__));
  *Out = CorrectTypoDelayed(
      R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC,
      [=](const TypoCorrection &TC) {
        emitEmptyLookupTypoDiagnostic(TC, *this, SS, Name, TypoLoc, Args,
                                      diagnostic, diagnostic_suggest);
      },
      nullptr, CTK_ErrorRecovery);
  if (*Out)
    return true;
} else if (S &&
           (Corrected = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(),
                                    S, &SS, CCC, CTK_ErrorRecovery))) {
  std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
  bool DroppedSpecifier =
      Corrected.WillReplaceSpecifier() && Name.getAsString() == CorrectedStr;
  R.setLookupName(Corrected.getCorrection());

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

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

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

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

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

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

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

2263ExprResult
2264Sema::ActOnIdExpression(Scope *S, CXXScopeSpec &SS,
                      SourceLocation TemplateKWLoc, UnqualifiedId &Id,
                      bool HasTrailingLParen, bool IsAddressOfOperand,
                      CorrectionCandidateCallback *CCC,
                      bool IsInlineAsmIdentifier, Token *KeywordReplacement) {
assert(!(IsAddressOfOperand && HasTrailingLParen) &&((!(IsAddressOfOperand && HasTrailingLParen) &&
 "cannot be direct & operand and have a trailing lparen")
 ? static_cast<void> (0) : __assert_fail ("!(IsAddressOfOperand && HasTrailingLParen) && \"cannot be direct & operand and have a trailing lparen\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2270, __PRETTY_FUNCTION__))
       "cannot be direct & operand and have a trailing lparen")((!(IsAddressOfOperand && HasTrailingLParen) &&
 "cannot be direct & operand and have a trailing lparen")
 ? static_cast<void> (0) : __assert_fail ("!(IsAddressOfOperand && HasTrailingLParen) && \"cannot be direct & operand and have a trailing lparen\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2270, __PRETTY_FUNCTION__));
if (SS.isInvalid())
  return ExprError();

TemplateArgumentListInfo TemplateArgsBuffer;

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

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

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

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

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

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

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

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

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

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

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

// This could be an implicitly declared function reference (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) &&(((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&
 "Typo correction callback misconfigured") ? static_cast<void
> (0) : __assert_fail ("(!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && \"Typo correction callback misconfigured\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2395, __PRETTY_FUNCTION__))
         "Typo correction callback misconfigured")(((!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) &&
 "Typo correction callback misconfigured") ? static_cast<void
> (0) : __assert_fail ("(!CCC || CCC->IsAddressOfOperand == IsAddressOfOperand) && \"Typo correction callback misconfigured\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2395, __PRETTY_FUNCTION__));
  if (CCC) {
    // Make sure the callback knows what the typo being diagnosed is.
    CCC->setTypoName(II);
    if (SS.isValid())
      CCC->setTypoNNS(SS.getScopeRep());
  }
  // FIXME: DiagnoseEmptyLookup produces bad diagnostics if we're looking for
  // a template name, but we happen to have always already looked up the name
  // before we get here if it must be a template name.
  if (DiagnoseEmptyLookup(S, SS, R, CCC ? *CCC : DefaultValidator, nullptr,
                          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() &&((!R.empty() && "DiagnoseEmptyLookup returned false but added no results"
) ? static_cast<void> (0) : __assert_fail ("!R.empty() && \"DiagnoseEmptyLookup returned false but added no results\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2431, __PRETTY_FUNCTION__))
         "DiagnoseEmptyLookup returned false but added no results")((!R.empty() && "DiagnoseEmptyLookup returned false but added no results"
) ? static_cast<void> (0) : __assert_fail ("!R.empty() && \"DiagnoseEmptyLookup returned false but added no results\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2431, __PRETTY_FUNCTION__));

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

// This is guaranteed from this point on.
assert(!R.empty() || ADL)((!R.empty() || ADL) ? static_cast<void> (0) : __assert_fail
 ("!R.empty() || ADL", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2448, __PRETTY_FUNCTION__));

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

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

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

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

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

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

2511/// BuildQualifiedDeclarationNameExpr - Build a C++ qualified
2512/// declaration name, generally during template instantiation.
2513/// There's a large number of things which don't need to be done along
2514/// this path.
2515ExprResult 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()) {
  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);
2587}

2589/// The parser has read a name in, and Sema has detected that we're currently
2590/// inside an ObjC method. Perform some additional checks and determine if we
2591/// should form a reference to an ivar.
2592///
2593/// Ideally, most of this would be done by lookup, but there's
2594/// actually quite a lot of extra work involved.
2595DeclResult 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);
2666}

2668ExprResult Sema::BuildIvarRefExpr(Scope *S, SourceLocation Loc,
                                ObjCIvarDecl *IV) {
ObjCMethodDecl *CurMethod = getCurMethodDecl();
assert(CurMethod && CurMethod->isInstanceMethod() &&((CurMethod && CurMethod->isInstanceMethod() &&
 "should not reference ivar from this context") ? static_cast
<void> (0) : __assert_fail ("CurMethod && CurMethod->isInstanceMethod() && \"should not reference ivar from this context\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2672, __PRETTY_FUNCTION__))
       "should not reference ivar from this context")((CurMethod && CurMethod->isInstanceMethod() &&
 "should not reference ivar from this context") ? static_cast
<void> (0) : __assert_fail ("CurMethod && CurMethod->isInstanceMethod() && \"should not reference ivar from this context\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2672, __PRETTY_FUNCTION__));

ObjCInterfaceDecl *IFace = CurMethod->getClassInterface();
assert(IFace && "should not reference ivar from this context")((IFace && "should not reference ivar from this context"
) ? static_cast<void> (0) : __assert_fail ("IFace && \"should not reference ivar from this context\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2675, __PRETTY_FUNCTION__));

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

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

// FIXME: This should use a new expr for a direct reference, don't
// turn this into Self->ivar, just return a BareIVarExpr or something.
IdentifierInfo &II = Context.Idents.get("self");
UnqualifiedId SelfName;
SelfName.setIdentifier(&II, SourceLocation());
SelfName.setKind(UnqualifiedIdKind::IK_ImplicitSelfParam);
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;
2726}

2728/// The parser has read a name in, and Sema has detected that we're currently
2729/// inside an ObjC method. Perform some additional checks and determine if we
2730/// should form a reference to an ivar. If so, build an expression referencing
2731/// that ivar.
2732ExprResult
2733Sema::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);
2748}

2750/// Cast a base object to a member's actual type.
2751///
2752/// Logically this happens in three phases:
2753///
2754/// * First we cast from the base type to the naming class.
2755///   The naming class is the class into which we were looking
2756///   when we found the member;  it's the qualifier type if a
2757///   qualifier was provided, and otherwise it's the base type.
2758///
2759/// * Next we cast from the naming class to the declaring class.
2760///   If the member we found was brought into a class's scope by
2761///   a using declaration, this is that class;  otherwise it's
2762///   the class declaring the member.
2763///
2764/// * Finally we cast from the declaring class to the "true"
2765///   declaring class of the member.  This conversion does not
2766///   obey access control.
2767ExprResult
2768Sema::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")((QType->isRecordType() && "lookup done with non-record type"
) ? static_cast<void> (0) : __assert_fail ("QType->isRecordType() && \"lookup done with non-record type\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2862, __PRETTY_FUNCTION__));

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

bool IgnoreAccess = false;

// If we actually found the member through a using declaration, cast
// down to the using declaration's type.
//
// Pointer equality is fine here because only one declaration of a
// class ever has member declarations.
if (FoundDecl->getDeclContext() != Member->getDeclContext()) {
  assert(isa<UsingShadowDecl>(FoundDecl))((isa<UsingShadowDecl>(FoundDecl)) ? static_cast<void
> (0) : __assert_fail ("isa<UsingShadowDecl>(FoundDecl)"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2898, __PRETTY_FUNCTION__));
  QualType URecordType = Context.getTypeDeclType(
                         cast<CXXRecordDecl>(FoundDecl->getDeclContext()));

  // We only need to do this if the naming-class to declaring-class
  // conversion is non-trivial.
  if (!Context.hasSameUnqualifiedType(FromRecordType, URecordType)) {
    assert(IsDerivedFrom(FromLoc, FromRecordType, URecordType))((IsDerivedFrom(FromLoc, FromRecordType, URecordType)) ? static_cast
<void> (0) : __assert_fail ("IsDerivedFrom(FromLoc, FromRecordType, URecordType)"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 2905, __PRETTY_FUNCTION__));
    CXXCastPath BasePath;
    if (CheckDerivedToBaseConversion(FromRecordType, URecordType,
                                     FromLoc, FromRange, &BasePath))
      return ExprError();

    QualType UType = URecordType;
    if (PointerConversions)
      UType = Context.getPointerType(UType);
    From = ImpCastExprToType(From, UType, CK_UncheckedDerivedToBase,
                             VK, &BasePath).get();
    FromType = UType;
    FromRecordType = URecordType;
  }

  // We don't do access control for the conversion from the
  // declaring class to the true declaring class.
  IgnoreAccess = true;
}

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

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

2935bool 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;
2986}


2989/// Diagnoses obvious problems with the use of the given declaration
2990/// as an expression.  This is only actually called for lookups that
2991/// were not overloaded, and it doesn't promise that the declaration
2992/// will in fact be used.
2993static 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;
3013}

3015// Certain multiversion types should be treated as overloaded even when there is
3016// only one result.
3017static bool ShouldLookupResultBeMultiVersionOverload(const LookupResult &R) {
assert(R.isSingleResult() && "Expected only a single result")((R.isSingleResult() && "Expected only a single result"
) ? static_cast<void> (0) : __assert_fail ("R.isSingleResult() && \"Expected only a single result\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3018, __PRETTY_FUNCTION__));
const auto *FD = dyn_cast<FunctionDecl>(R.getFoundDecl());
return FD &&
       (FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion());
3022}

3024ExprResult 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;
3056}

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

3062/// Complete semantic analysis for a reference to the given declaration.
3063ExprResult 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")((D && "Cannot refer to a NULL declaration") ? static_cast
<void> (0) : __assert_fail ("D && \"Cannot refer to a NULL declaration\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3067, __PRETTY_FUNCTION__));
assert(!isa<FunctionTemplateDecl>(D) &&((!isa<FunctionTemplateDecl>(D) && "Cannot refer unambiguously to a function template"
) ? static_cast<void> (0) : __assert_fail ("!isa<FunctionTemplateDecl>(D) && \"Cannot refer unambiguously to a function template\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3069, __PRETTY_FUNCTION__))
       "Cannot refer unambiguously to a function template")((!isa<FunctionTemplateDecl>(D) && "Cannot refer unambiguously to a function template"
) ? static_cast<void> (0) : __assert_fail ("!isa<FunctionTemplateDecl>(D) && \"Cannot refer unambiguously to a function template\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3069, __PRETTY_FUNCTION__));

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.
ValueDecl *VD = dyn_cast<ValueDecl>(D);
if (!VD) {
  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(VD, Loc))
  return ExprError();

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

  switch (D->getKind()) {
  // Ignore all the non-ValueDecl kinds.
3118#define ABSTRACT_DECL(kind)
3119#define VALUE(type, base)
3120#define DECL(type, base) \
  case Decl::type:
3122#include "clang/AST/DeclNodes.inc"
    llvm_unreachable("invalid value decl kind")::llvm::llvm_unreachable_internal("invalid value decl kind", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3123);

  // These shouldn't make it here.
  case Decl::ObjCAtDefsField:
    llvm_unreachable("forming non-member reference to ivar?")::llvm::llvm_unreachable_internal("forming non-member reference to ivar?"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3127);

  // 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_RValue;
    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 &&((getLangOpts().CPlusPlus && "building reference to field in C?"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"building reference to field in C?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3146, __PRETTY_FUNCTION__))
           "building reference to field in C?")((getLangOpts().CPlusPlus && "building reference to field in C?"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().CPlusPlus && \"building reference to field in C?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3146, __PRETTY_FUNCTION__));

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

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

    // For non-references, we need to strip qualifiers just in case
    // the template parameter was declared as 'const int' or whatever.
    valueKind = VK_RValue;
    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_RValue;
      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_RValue;
        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_RValue;
      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_RValue;
    break;
  }

  case Decl::CXXDeductionGuide:
    llvm_unreachable("building reference to deduction guide")::llvm::llvm_unreachable_internal("building reference to deduction guide"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3258);

  case Decl::MSProperty:
    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_RValue;
        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_RValue;
    break;
  }

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

3296static 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)((success) ? static_cast<void> (0) : __assert_fail ("success"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3304, __PRETTY_FUNCTION__));
Target.resize(ResultPtr - &Target[0]);
3306}

3308ExprResult 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);
3359}

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

switch (Kind) {
default: llvm_unreachable("Unknown simple primary expr!")::llvm::llvm_unreachable_internal("Unknown simple primary expr!"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3365);
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);
3376}

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

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

3441static 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);
3471}

3473bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {
assert(E && "Invalid expression")((E && "Invalid expression") ? static_cast<void>
 (0) : __assert_fail ("E && \"Invalid expression\"", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3474, __PRETTY_FUNCTION__));

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

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

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

if (R.isInvalid())
  return true;

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

return false;
3499}

3501ExprResult 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);
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,
                                /*AllowStringTemplate*/ 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_StringTemplate:
    llvm_unreachable("unexpected literal operator lookup result")::llvm::llvm_unreachable_internal("unexpected literal operator lookup result"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3617);
  }
}

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().isEnabled("cl_khr_fp16"))
      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) {
      const BuiltinType *BTy = Ty->getAs<BuiltinType>();
      if (BTy->getKind() != BuiltinType::Float) {
        Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
      }
    } else if (getLangOpts().OpenCL &&
               !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
      // Impose single-precision float type when cl_khr_fp64 is not enabled.
      Diag(Tok.getLocation(), diag::warn_double_const_requires_fp64);
      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);
  }

  // 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() &&((Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
 "long long is not intmax_t?") ? static_cast<void> (0) :
 __assert_fail ("Context.getTypeSize(Ty) == ResultVal.getBitWidth() && \"long long is not intmax_t?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3726, __PRETTY_FUNCTION__))
           "long long is not intmax_t?")((Context.getTypeSize(Ty) == ResultVal.getBitWidth() &&
 "long long is not intmax_t?") ? static_cast<void> (0) :
 __assert_fail ("Context.getTypeSize(Ty) == ResultVal.getBitWidth() && \"long long is not intmax_t?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3726, __PRETTY_FUNCTION__));
  } else {
    // If this value fits into a ULL, try to figure out what else it fits into
    // according to the rules of C99 6.4.4.1p5.

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

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

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

    if (Ty.isNull() && !Literal.isLong && !Literal.isLongLong) {
      // 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) {
      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()) {
      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 probably have something that
    // does not fit in a signed long long, but has no U suffix.
    if (Ty.isNull()) {
      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;
3836}

3838ExprResult Sema::ActOnParenExpr(SourceLocation L, SourceLocation R, Expr *E) {
assert(E && "ActOnParenExpr() missing expr")((E && "ActOnParenExpr() missing expr") ? static_cast
<void> (0) : __assert_fail ("E && \"ActOnParenExpr() missing expr\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3839, __PRETTY_FUNCTION__));
return new (Context) ParenExpr(L, R, E);
3841}

3843static 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()) &&(((T->isVoidType() || !T->isIncompleteType()) &&
 "Scalar types should always be complete") ? static_cast<void
> (0) : __assert_fail ("(T->isVoidType() || !T->isIncompleteType()) && \"Scalar types should always be complete\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3857, __PRETTY_FUNCTION__))
       "Scalar types should always be complete")(((T->isVoidType() || !T->isIncompleteType()) &&
 "Scalar types should always be complete") ? static_cast<void
> (0) : __assert_fail ("(T->isVoidType() || !T->isIncompleteType()) && \"Scalar types should always be complete\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3857, __PRETTY_FUNCTION__));
return false;
3859}

3861static 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)
    << 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) << TraitKind << ArgRange;
  return false;
}

return true;
3889}

3891static 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;
3905}

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

3925/// Check the constraints on expression operands to unary type expression
3926/// and type traits.
3927///
3928/// Completes any types necessary and validates the constraints on the operand
3929/// expression. The logic mostly mirrors the type-based overload, but may modify
3930/// the expression as it completes the type for that expression through template
3931/// instantiation, etc.
3932bool Sema::CheckUnaryExprOrTypeTraitOperand(Expr *E,
                                          UnaryExprOrTypeTrait ExprKind) {
QualType ExprTy = E->getType();
assert(!ExprTy->isReferenceType())((!ExprTy->isReferenceType()) ? static_cast<void> (0
) : __assert_fail ("!ExprTy->isReferenceType()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3935, __PRETTY_FUNCTION__));

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

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

// Whitelist 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 (RequireCompleteType(E->getExprLoc(),
                          Context.getBaseElementType(E->getType()),
                          diag::err_sizeof_alignof_incomplete_type, ExprKind,
                          E->getSourceRange()))
    return true;
} else {
  if (RequireCompleteExprType(E, diag::err_sizeof_alignof_incomplete_type,
                              ExprKind, E->getSourceRange()))
    return true;
}

// Completing the expression's type may have changed it.
ExprTy = E->getType();
assert(!ExprTy->isReferenceType())((!ExprTy->isReferenceType()) ? static_cast<void> (0
) : __assert_fail ("!ExprTy->isReferenceType()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 3974, __PRETTY_FUNCTION__));

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

// The operand for sizeof and alignof is in an unevaluated expression context,
// so side effects could result in unintended consequences.
if (IsUnevaluatedOperand && !inTemplateInstantiation() &&
    E->HasSideEffects(Context, false))
  Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);

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

4019/// Check the constraints on operands to unary expression and type
4020/// traits.
4021///
4022/// This will complete any types necessary, and validate the various constraints
4023/// on those operands.
4024///
4025/// The UsualUnaryConversions() function is *not* called by this routine.
4026/// C99 6.3.2.1p[2-4] all state:
4027///   Except when it is the operand of the sizeof operator ...
4028///
4029/// C++ [expr.sizeof]p4
4030///   The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
4031///   standard conversions are not applied to the operand of sizeof.
4032///
4033/// This policy is followed for all of the unary trait expressions.
4034bool 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);

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

if (RequireCompleteType(OpLoc, ExprType,
                        diag::err_sizeof_alignof_incomplete_type,
                        ExprKind, ExprRange))
  return true;

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

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

return false;
4081}

4083static 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);
4137}

4139bool 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);
4147}

4149static void captureVariablyModifiedType(ASTContext &Context, QualType T,
                                      CapturingScopeInfo *CSI) {
assert(T->isVariablyModifiedType())((T->isVariablyModifiedType()) ? static_cast<void> (
0) : __assert_fail ("T->isVariablyModifiedType()", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4151, __PRETTY_FUNCTION__));
assert(CSI != nullptr)((CSI != nullptr) ? static_cast<void> (0) : __assert_fail
 ("CSI != nullptr", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4152, __PRETTY_FUNCTION__));

// We're going to walk down into the type and look for VLA expressions.
do {
  const Type *Ty = T.getTypePtr();
  switch (Ty->getTypeClass()) {
4158#define TYPE(Class, Base)
4159#define ABSTRACT_TYPE(Class, Base)
4160#define NON_CANONICAL_TYPE(Class, Base)
4161#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4162#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)
4163#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::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:
    llvm_unreachable("type class is never variably-modified!")::llvm::llvm_unreachable_internal("type class is never variably-modified!"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4180);
  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::PackExpansion:
  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());
4251}

4253/// Build a sizeof or alignof expression given a type operand.
4254ExprResult
4255Sema::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());
4295}

4297/// Build a sizeof or alignof expression given an expression
4298/// operand.
4299ExprResult
4300Sema::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());
4338}

4340/// ActOnUnaryExprOrTypeTraitExpr - Handle @c sizeof(type) and @c sizeof @c
4341/// expr and the same for @c alignof and @c __alignof
4342/// Note that the ArgRange is invalid if isType is false.
4343ExprResult
4344Sema::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;
4359}

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



4397ExprResult
4398Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
                        tok::TokenKind Kind, Expr *Input) {
UnaryOperatorKind Opc;
switch (Kind) {
default: llvm_unreachable("Unknown unary op!")::llvm::llvm_unreachable_internal("Unknown unary op!", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4402);
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);
4413}

4415/// Diagnose if arithmetic on the given ObjC pointer is illegal.
4416///
4417/// \return true on error
4418static bool checkArithmeticOnObjCPointer(Sema &S,
                                       SourceLocation opLoc,
                                       Expr *op) {
assert(op->getType()->isObjCObjectPointerType())((op->getType()->isObjCObjectPointerType()) ? static_cast
<void> (0) : __assert_fail ("op->getType()->isObjCObjectPointerType()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4421, __PRETTY_FUNCTION__));
if (S.LangOpts.ObjCRuntime.allowsPointerArithmetic() &&
    !S.LangOpts.ObjCSubscriptingLegacyRuntime)
  return false;

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

4432static 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);
4437}

4439ExprResult
4440Sema::ActOnArraySubscriptExpr(Scope *S, Expr *base, SourceLocation lbLoc,
                            Expr *idx, SourceLocation rbLoc) {
if (base8.1
'base' is non-null
1
'base' is non-null
 && !base->getType().isNull() &&
9
←
Taking false branch→
    base->getType()->isSpecificPlaceholderType(BuiltinType::OMPArraySection))
  return ActOnOMPArraySectionExpr(base, lbLoc, idx, SourceLocation(),
                                  /*Length=*/nullptr, rbLoc);

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

// A comma-expression as the index is deprecated in C++2a onwards.
if (getLangOpts().CPlusPlus2a &&
12
←
Assuming field 'CPlusPlus2a' is 0→
    ((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);
}

// 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()) {
13
←
Taking false branch→
  IsMSPropertySubscript = isMSPropertySubscriptExpr(*this, base);
  if (!IsMSPropertySubscript) {
    ExprResult result = CheckPlaceholderExpr(base);
    if (result.isInvalid())
      return ExprError();
    base = result.get();
  }
}
if (idx->getType()->isNonOverloadPlaceholderType()) {
14
←
Taking false branch→
  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 &&
15
←
Assuming field 'CPlusPlus' is 0→
    (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 (IsMSPropertySubscript15.1
'IsMSPropertySubscript' is false
1
'IsMSPropertySubscript' is false
) {
16
←
Taking false branch→
  // 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().CPlusPlus16.1
Field 'CPlusPlus' is 0
1
Field 'CPlusPlus' is 0
 &&
17
←
Taking false branch→
    (base->getType()->isRecordType() ||
     (!base->getType()->isObjCObjectPointerType() &&
      idx->getType()->isRecordType()))) {
  return CreateOverloadedArraySubscriptExpr(lbLoc, rbLoc, base, idx);
}

ExprResult Res = CreateBuiltinArraySubscriptExpr(base, lbLoc, idx, rbLoc);
18
←
Calling 'Sema::CreateBuiltinArraySubscriptExpr'→

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

return Res;
4527}

4529void 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);
4540}

4542void Sema::CheckSubscriptAccessOfNoDeref(const ArraySubscriptExpr *E) {
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);
}
4572}

4574ExprResult Sema::ActOnOMPArraySectionExpr(Expr *Base, SourceLocation LBLoc,
                                        Expr *LowerBound,
                                        SourceLocation ColonLoc, Expr *Length,
                                        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();
}

// Build an unanalyzed expression if either operand is type-dependent.
if (Base->isTypeDependent() ||
    (LowerBound &&
     (LowerBound->isTypeDependent() || LowerBound->isValueDependent())) ||
    (Length && (Length->isTypeDependent() || Length->isValueDependent()))) {
  return new (Context)
      OMPArraySectionExpr(Base, LowerBound, Length, Context.DependentTy,
                          VK_LValue, OK_Ordinary, ColonLoc, 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();
}

// 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 4.5, [2.4 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 4.5, [2.4 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)
          << LengthValue.toString(/*Radix=*/10, /*Signed=*/true)
          << Length->getSourceRange();
      return ExprError();
    }
  }
} else if (ColonLoc.isValid() &&
           (OriginalTy.isNull() || (!OriginalTy->isConstantArrayType() &&
                                    !OriginalTy->isVariableArrayType()))) {
  // OpenMP 4.5, [2.4 Array Sections]
  // When the size of the array dimension is not known, the length must be
  // specified explicitly.
  Diag(ColonLoc, diag::err_omp_section_length_undefined)
      << (!OriginalTy.isNull() && OriginalTy->isArrayType());
  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, Context.OMPArraySectionTy,
                        VK_LValue, OK_Ordinary, ColonLoc, RBLoc);
4719}

4721ExprResult
4722Sema::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) {
19
←
Assuming field 'CPlusPlus11' is 0→
20
←
Taking false branch→
  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>()) {
21
←
Assuming the object is not a 'VectorType'→
22
←
Taking true branch→
  ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
  if (Result.isInvalid())
23
←
Taking false branch→
    return ExprError();
  LHSExp = Result.get();
}
ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
if (Result.isInvalid())
24
←
Taking false branch→
  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()) {
25
←
Assuming the condition is false→
26
←
Assuming the condition is false→
27
←
Taking false branch→
  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  ResultType = Context.DependentTy;
} else if (const PointerType *PTy28.1
'PTy' is null
1
'PTy' is null
 = LHSTy->getAs<PointerType>()) {
28
←
Assuming the object is not a 'PointerType'→
29
←
Taking false branch→
  BaseExpr = LHSExp;
  IndexExpr = RHSExp;
  ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy30.1
'PTy' is null
1
'PTy' is null
 =
31
←
Taking false branch→
             LHSTy->getAs<ObjCObjectPointerType>()) {
30
←
Assuming the object is not a '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 *PTy32.1
'PTy' is null
1
'PTy' is null
 = RHSTy->getAs<PointerType>()) {
32
←
Assuming the object is not a 'PointerType'→
33
←
Taking false branch→
   // Handle the uncommon case of "123[Ptr]".
  BaseExpr = RHSExp;
  IndexExpr = LHSExp;
  ResultType = PTy->getPointeeType();
} else if (const ObjCObjectPointerType *PTy34.1
'PTy' is null
1
'PTy' is null
 =
35
←
Taking false branch→
             RHSTy->getAs<ObjCObjectPointerType>()) {
34
←
Assuming the object is not a '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 *VTy36.1
'VTy' is null
1
'VTy' is null
 = LHSTy->getAs<VectorType>()) {
36
←
Assuming the object is not a 'VectorType'→
37
←
Taking false branch→
  BaseExpr = LHSExp;    // vectors: V[123]
  IndexExpr = RHSExp;
  // We apply C++ DR1213 to vector subscripting too.
  if (getLangOpts().CPlusPlus11 && LHSExp->getValueKind() == VK_RValue) {
    ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
    if (Materialized.isInvalid())
      return ExprError();
    LHSExp = Materialized.get();
  }
  VK = LHSExp->getValueKind();
  if (VK != VK_RValue)
    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()) {
38
←
Calling 'Type::isArrayType'→
41
←
Returning from 'Type::isArrayType'→
42
←
Taking false branch→
  // 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->getAs<PointerType>()->getPointeeType();
} else if (RHSTy->isArrayType()) {
43
←
Calling 'Type::isArrayType'→
46
←
Returning from 'Type::isArrayType'→
47
←
Taking true branch→
  // 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->getAs<PointerType>()->getPointeeType();
48
←
Assuming the object is not a 'PointerType'→
49
←
Called C++ object pointer is null
} 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_RValue;
} else if (!ResultType->isDependentType() &&
    RequireCompleteType(LLoc, ResultType,
                        diag::err_subscript_incomplete_type, BaseExpr))
  return ExprError();

assert(VK == VK_RValue || LangOpts.CPlusPlus ||((VK == VK_RValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType
()) ? static_cast<void> (0) : __assert_fail ("VK == VK_RValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4881, __PRETTY_FUNCTION__))
       !ResultType.isCForbiddenLValueType())((VK == VK_RValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType
()) ? static_cast<void> (0) : __assert_fail ("VK == VK_RValue || LangOpts.CPlusPlus || !ResultType.isCForbiddenLValueType()"
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 4881, __PRETTY_FUNCTION__));

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

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

4914bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
                                ParmVarDecl *Param) {
if (Param->hasUnparsedDefaultArg()) {
  Diag(CallLoc,
       diag::err_use_of_default_argument_to_function_declared_later) <<
    FD << cast<CXXRecordDecl>(FD->getDeclContext())->getDeclName();
  Diag(UnparsedDefaultArgLocs[Param],
       diag::note_default_argument_declared_here);
  return true;
}

if (Param->hasUninstantiatedDefaultArg()) {
  Expr *UninstExpr = Param->getUninstantiatedDefaultArg();

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

  // Instantiate the expression.
  //
  // FIXME: Pass in a correct Pattern argument, otherwise
  // getTemplateInstantiationArgs uses the lexical context of FD, e.g.
  //
  // template<typename T>
  // struct A {
  //   static int FooImpl();
  //
  //   template<typename Tp>
  //   // bug: default argument A<T>::FooImpl() is evaluated with 2-level
  //   // template argument list [[T], [Tp]], should be [[Tp]].
  //   friend A<Tp> Foo(int a);
  // };
  //
  // template<typename T>
  // A<T> Foo(int a = A<T>::FooImpl());
  MultiLevelTemplateArgumentList MutiLevelArgList
    = getTemplateInstantiationArgs(FD, nullptr, /*RelativeToPrimary=*/true);

  InstantiatingTemplate Inst(*this, CallLoc, Param,
                             MutiLevelArgList.getInnermost());
  if (Inst.isInvalid())
    return true;
  if (Inst.isAlreadyInstantiating()) {
    Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
    Param->setInvalidDecl();
    return true;
  }

  ExprResult Result;
  {
    // C++ [dcl.fct.default]p5:
    //   The names in the [default argument] expression are bound, and
    //   the semantic constraints are checked, at the point where the
    //   default argument expression appears.
    ContextRAII SavedContext(*this, FD);
    LocalInstantiationScope Local(*this);
    runWithSufficientStackSpace(CallLoc, [&] {
      Result = SubstInitializer(UninstExpr, MutiLevelArgList,
                                /*DirectInit*/false);
    });
  }
  if (Result.isInvalid())
    return true;

  // Check the expression as an initializer for the parameter.
  InitializedEntity Entity
    = InitializedEntity::InitializeParameter(Context, Param);
  InitializationKind Kind = InitializationKind::CreateCopy(
      Param->getLocation(),
      /*FIXME:EqualLoc*/ UninstExpr->getBeginLoc());
  Expr *ResultE = Result.getAs<Expr>();

  InitializationSequence InitSeq(*this, Entity, Kind, ResultE);
  Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
  if (Result.isInvalid())
    return true;

  Result =
      ActOnFinishFullExpr(Result.getAs<Expr>(), Param->getOuterLocStart(),
                          /*DiscardedValue*/ false);
  if (Result.isInvalid())
    return true;

  // Remember the instantiated default argument.
  Param->setDefaultArg(Result.getAs<Expr>());
  if (ASTMutationListener *L = getASTMutationListener()) {
    L->DefaultArgumentInstantiated(Param);
  }
}

// If the default argument expression is not set yet, we are building it now.
if (!Param->hasInit()) {
  Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;
  Param->setInvalidDecl();
  return true;
}

// 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() &&((!Init->getNumObjects() && "default argument expression has capturing blocks?"
) ? static_cast<void> (0) : __assert_fail ("!Init->getNumObjects() && \"default argument expression has capturing blocks?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5026, __PRETTY_FUNCTION__))
         "default argument expression has capturing blocks?")((!Init->getNumObjects() && "default argument expression has capturing blocks?"
) ? static_cast<void> (0) : __assert_fail ("!Init->getNumObjects() && \"default argument expression has capturing blocks?\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5026, __PRETTY_FUNCTION__));
}

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

5039ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
                                      FunctionDecl *FD, ParmVarDecl *Param) {
if (CheckCXXDefaultArgExpr(CallLoc, FD, Param))
  return ExprError();
return CXXDefaultArgExpr::Create(Context, CallLoc, Param, CurContext);
5044}

5046Sema::VariadicCallType
5047Sema::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;
5063}

5065namespace {
5066class FunctionCallCCC final : public FunctionCallFilterCCC {
5067public:
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);
}

5086private:
const IdentifierInfo *const FunctionName;
5088};
5089}

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

5129/// ConvertArgumentsForCall - Converts the arguments specified in
5130/// Args/NumArgs to the parameter types of the function FDecl with
5131/// function prototype Proto. Call is the call expression itself, and
5132/// Fn is the function expression. For a C++ member function, this
5133/// routine does not attempt to convert the object argument. Returns
5134/// true if the call is ill-formed.
5135bool
5136Sema::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->getBeginLoc(), 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) &&(((Call->getNumArgs() == NumParams) && "We should have reserved space for the default arguments before!"
) ? static_cast<void> (0) : __assert_fail ("(Call->getNumArgs() == NumParams) && \"We should have reserved space for the default arguments before!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5193, __PRETTY_FUNCTION__))
         "We should have reserved space for the default arguments before!")(((Call->getNumArgs() == NumParams) && "We should have reserved space for the default arguments before!"
) ? static_cast<void> (0) : __assert_fail ("(Call->getNumArgs() == NumParams) && \"We should have reserved space for the default arguments before!\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5193, __PRETTY_FUNCTION__));
}

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

    // Emit the location of the prototype.
    if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)
      Diag(FDecl->getBeginLoc(), 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]);

return false;
5250}

5252bool 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())
      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")((Param && "can't use default arguments without a known callee"
) ? static_cast<void> (0) : __assert_fail ("Param && \"can't use default arguments without a known callee\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5306, __PRETTY_FUNCTION__));

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

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

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

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

  AllArgs.push_back(Arg);
}

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

  // Otherwise do argument promotion, (C99 6.5.2.2p7).
  } else {
    for (Expr *A : Args.slice(ArgIx)) {
      ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
      Invalid |= Arg.isInvalid();
      // Copy blocks to the heap.
      if (A->getType()->isBlockPointerType())
        maybeExtendBlockObject(Arg);
      AllArgs.push_back(Arg.get());
    }
  }

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

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

5367/// CheckStaticArrayArgument - If the given argument corresponds to a static
5368/// array parameter, check that it is non-null, and that if it is formed by
5369/// array-to-pointer decay, the underlying array is sufficiently large.
5370///
5371/// C99 6.7.5.3p7: If the keyword static also appears within the [ and ] of the
5372/// array type derivation, then for each call to the function, the value of the
5373/// corresponding actual argument shall provide access to the first element of
5374/// an array with at least as many elements as specified by the size expression.
5375void
5376Sema::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);
}
5426}

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

5432/// Is the given type a placeholder that we need to lower out
5433/// immediately during argument processing?
5434static 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.
5441#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
5443#include "clang/Basic/OpenCLImageTypes.def"
5444#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
case BuiltinType::Id:
5446#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.
5449#define SVE_TYPE(Name, Id, SingletonId) \
case BuiltinType::Id:
5451#include "clang/Basic/AArch64SVEACLETypes.def"
5452#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)
5453#define BUILTIN_TYPE(ID, SINGLETON_ID) case BuiltinType::ID:
5454#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::OMPArraySection:
  return true;

}
llvm_unreachable("bad builtin type kind")::llvm::llvm_unreachable_internal("bad builtin type kind", "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5483);
5484}

5486/// Check an argument list for placeholders that we won't try to
5487/// handle later.
5488static 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();
  } else if (hasInvalid) {
    (void)S.CorrectDelayedTyposInExpr(args[i]);
  }
}
return hasInvalid;
5502}

5504/// If a builtin function has a pointer argument with no explicit address
5505/// space, then it should be able to accept a pointer to any address
5506/// space as input.  In order to do this, we need to replace the
5507/// standard builtin declaration with one that uses the same address space
5508/// as the call.
5509///
5510/// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
5511///                  it does not contain any pointer arguments without
5512///                  an address space qualifer.  Otherwise the rewritten
5513///                  FunctionDecl is returned.
5514/// TODO: Handle pointer return types.
5515static 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);
return OverloadDecl;
5587}

5589static 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, 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;
}
5613}

5615static 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")((NamingClass && "Must have naming class even for implicit access"
) ? static_cast<void> (0) : __assert_fail ("NamingClass && \"Must have naming class even for implicit access\""
, "/build/llvm-toolchain-snapshot-10~++20200112100611+7fa5290d5bd/clang/lib/Sema/SemaExpr.cpp"
, 5646, __PRETTY_FUNCTION__));

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

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

5656static void
5657tryImplicitlyCaptureThisIfImplicitMemberFunctionAccessWithDependentArgs(
  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);
}
5694}

5696ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                             MultiExprArg ArgExprs, SourceLocation RParenLoc,
                             Expr *ExecConfig) {
ExprResult Call =
    BuildCallExpr(Scope, Fn, LParenLoc, ArgExprs, RParenLoc, ExecConfig);
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().CPlusPlus2a
                               ? diag::warn_cxx17_compat_adl_only_template_id
                               : diag::ext_adl_only_template_id)
        << ULE->getName();
  }
}

return Call;
5717}

5719/// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
5720/// This provides the location of the left/right parens and a list of comma
5721/// locations.
5722ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                             MultiExprArg ArgExprs, SourceLocation RParenLoc,
                             Expr *ExecConfig, bool IsExecConfig) {
// 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_RValue, RParenLoc);
  }
  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_RValue, RParenLoc);
    } else {

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

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

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

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

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

  if (getLangOpts().OpenCL && checkOpenCLDisabledDecl(*FD, *Fn))
    return ExprError();

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

return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
                             ExecConfig, IsExecConfig);
5858}

5860/// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
5861///
5862/// __builtin_astype( value, dst type )
5863///
5864ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                               SourceLocation BuiltinLoc,
                               SourceLocation RParenLoc) {
ExprValueKind VK = VK_RValue;
ExprObjectKind OK = OK_Ordinary;
QualType DstTy = GetTypeFromParser(ParsedDestTy);
QualType SrcTy = E->getType();
if (Context.getTypeSize(DstTy) != Context.getTypeSize(SrcTy))
  return ExprError(Diag(BuiltinLoc,
                        diag::err_invalid_astype_of_different_size)
                   << DstTy
                   << SrcTy
                   << E->getSourceRange());
return new (Context) AsTypeExpr(E, DstTy, VK, OK, BuiltinLoc, RParenLoc);
5878}

5880/// ActOnConvertVectorExpr - create a new convert-vector expression from the
5881/// provided arguments.
5882///
5883/// __builtin_convertvector( value, dst type )
5884///