//===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file implements semantic analysis for expressions.

//

//===----------------------------------------------------------------------===//

#include "TreeTransform.h"

#include "UsedDeclVisitor.h"

#include "clang/AST/ASTConsumer.h"

#include "clang/AST/ASTContext.h"

#include "clang/AST/ASTLambda.h"

#include "clang/AST/ASTMutationListener.h"

#include "clang/AST/CXXInheritance.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/EvaluatedExprVisitor.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprObjC.h"

#include "clang/AST/ExprOpenMP.h"

#include "clang/AST/OperationKinds.h"

#include "clang/AST/ParentMapContext.h"

#include "clang/AST/RecursiveASTVisitor.h"

#include "clang/AST/Type.h"

#include "clang/AST/TypeLoc.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/DiagnosticSema.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TargetInfo.h"

#include "clang/Basic/TypeTraits.h"

#include "clang/Lex/LiteralSupport.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/AnalysisBasedWarnings.h"

#include "clang/Sema/DeclSpec.h"

#include "clang/Sema/DelayedDiagnostic.h"

#include "clang/Sema/Designator.h"

#include "clang/Sema/EnterExpressionEvaluationContext.h"

#include "clang/Sema/Initialization.h"

#include "clang/Sema/Lookup.h"

#include "clang/Sema/Overload.h"

#include "clang/Sema/ParsedTemplate.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/ScopeInfo.h"

#include "clang/Sema/SemaFixItUtils.h"

#include "clang/Sema/SemaInternal.h"

#include "clang/Sema/Template.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/ADT/StringExtras.h"

#include "llvm/Support/Casting.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/SaveAndRestore.h"

#include "llvm/Support/TypeSize.h"

#include <optional>

using namespace clang;

using namespace sema;

/// Determine whether the use of this declaration is valid, without

/// emitting diagnostics.

bool Sema::CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid) {

  // See if this is an auto-typed variable whose initializer we are parsing.

  if (ParsingInitForAutoVars.count(D))

    return false;

  // See if this is a deleted function.

  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {

    if (FD->isDeleted())

      return false;

    // If the function has a deduced return type, and we can't deduce it,

    // then we can't use it either.

    if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&

        DeduceReturnType(FD, SourceLocation(), /*Diagnose*/ false))

      return false;

    // See if this is an aligned allocation/deallocation function that is

    // unavailable.

    if (TreatUnavailableAsInvalid &&

        isUnavailableAlignedAllocationFunction(*FD))

      return false;

  }

  // See if this function is unavailable.

  if (TreatUnavailableAsInvalid && D->getAvailability() == AR_Unavailable &&

      cast<Decl>(CurContext)->getAvailability() != AR_Unavailable)

    return false;

  if (isa<UnresolvedUsingIfExistsDecl>(D))

    return false;

  return true;

}

static 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::C23_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;

    }

  }

}

/// Emit a note explaining that this function is deleted.

void Sema::NoteDeletedFunction(FunctionDecl *Decl) {

  assert(Decl && Decl->isDeleted());

  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;

}

/// Determine whether a FunctionDecl was ever declared with an

/// explicit storage class.

static bool hasAnyExplicitStorageClass(const FunctionDecl *D) {

  for (auto *I : D->redecls()) {

    if (I->getStorageClass() != SC_None)

      return true;

  }

  return false;

}

/// Check whether we're in an extern inline function and referring to a

/// variable or function with internal linkage (C11 6.7.4p3).

///

/// This is only a warning because we used to silently accept this code, but

/// in many cases it will not behave correctly. This is not enabled in C++ mode

/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)

/// and so while there may still be user mistakes, most of the time we can't

/// prove that there are errors.

static 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() != Linkage::Internal)

    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;

}

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

  }

}

/// Determine whether the use of this declaration is valid, and

/// emit any corresponding diagnostics.

///

/// This routine diagnoses various problems with referencing

/// declarations that can occur when using a declaration. For example,

/// it might warn if a deprecated or unavailable declaration is being

/// used, or produce an error (and return true) if a C++0x deleted

/// function is being used.

///

/// \returns true if there was an error (this declaration cannot be

/// referenced), false otherwise.

///

bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,

                             const ObjCInterfaceDecl *UnknownObjCClass,

                             bool ObjCPropertyAccess,

                             bool AvoidPartialAvailabilityChecks,

                             ObjCInterfaceDecl *ClassReceiver,

                             bool SkipTrailingRequiresClause) {

  SourceLocation Loc = Locs.front();

  if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {

    // If there were any diagnostics suppressed by template argument deduction,

    // emit them now.

    auto Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());

    if (Pos != SuppressedDiagnostics.end()) {

      for (const PartialDiagnosticAt &Suppressed : Pos->second)

        Diag(Suppressed.first, Suppressed.second);

      // Clear out the list of suppressed diagnostics, so that we don't emit

      // them again for this specialization. However, we don't obsolete this

      // entry from the table, because we want to avoid ever emitting these

      // diagnostics again.

      Pos->second.clear();

    }

    // C++ [basic.start.main]p3:

    //   The function 'main' shall not be used within a program.

    if (cast<FunctionDecl>(D)->isMain())

      Diag(Loc, diag::ext_main_used);

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

  }

  // See if this is an auto-typed variable whose initializer we are parsing.

  if (ParsingInitForAutoVars.count(D)) {

    if (isa<BindingDecl>(D)) {

      Diag(Loc, diag::err_binding_cannot_appear_in_own_initializer)

        << D->getDeclName();

    } else {

      Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)

        << D->getDeclName() << cast<VarDecl>(D)->getType();

    }

    return true;

  }

  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {

    // See if this is a deleted function.

    if (FD->isDeleted()) {

      auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);

      if (Ctor && Ctor->isInheritingConstructor())

        Diag(Loc, diag::err_deleted_inherited_ctor_use)

            << Ctor->getParent()

            << Ctor->getInheritedConstructor().getConstructor()->getParent();

      else

        Diag(Loc, diag::err_deleted_function_use);

      NoteDeletedFunction(FD);

      return true;

    }

    // [expr.prim.id]p4

    //   A program that refers explicitly or implicitly to a function with a

    //   trailing requires-clause whose constraint-expression is not satisfied,

    //   other than to declare it, is ill-formed. [...]

    //

    // See if this is a function with constraints that need to be satisfied.

    // Check this before deducing the return type, as it might instantiate the

    // definition.

    if (!SkipTrailingRequiresClause && FD->getTrailingRequiresClause()) {

      ConstraintSatisfaction Satisfaction;

      if (CheckFunctionConstraints(FD, Satisfaction, Loc,

                                   /*ForOverloadResolution*/ true))

        // A diagnostic will have already been generated (non-constant

        // constraint expression, for example)

        return true;

      if (!Satisfaction.IsSatisfied) {

        Diag(Loc,

             diag::err_reference_to_function_with_unsatisfied_constraints)

            << D;

        DiagnoseUnsatisfiedConstraint(Satisfaction);

        return true;

      }

    }

    // If the function has a deduced return type, and we can't deduce it,

    // then we can't use it either.

    if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&

        DeduceReturnType(FD, Loc))

      return true;

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

      return true;

  }

  if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {

    // Lambdas are only default-constructible or assignable in C++2a onwards.

    if (MD->getParent()->isLambda() &&

        ((isa<CXXConstructorDecl>(MD) &&

          cast<CXXConstructorDecl>(MD)->isDefaultConstructor()) ||

         MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())) {

      Diag(Loc, diag::warn_cxx17_compat_lambda_def_ctor_assign)

        << !isa<CXXConstructorDecl>(MD);

    }

  }

  auto getReferencedObjCProp = [](const NamedDecl *D) ->

                                      const ObjCPropertyDecl * {

    if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))

      return MD->findPropertyDecl();

    return nullptr;

  };

  if (const ObjCPropertyDecl *ObjCPDecl = getReferencedObjCProp(D)) {

    if (diagnoseArgIndependentDiagnoseIfAttrs(ObjCPDecl, Loc))

      return true;

  } else if (diagnoseArgIndependentDiagnoseIfAttrs(D, Loc)) {

      return true;

  }

  // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions

  // Only the variables omp_in and omp_out are allowed in the combiner.

  // Only the variables omp_priv and omp_orig are allowed in the

  // initializer-clause.

  auto *DRD = dyn_cast<OMPDeclareReductionDecl>(CurContext);

  if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&

      isa<VarDecl>(D)) {

    Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)

        << getCurFunction()->HasOMPDeclareReductionCombiner;

    Diag(D->getLocation(), diag::note_entity_declared_at) << D;

    return true;

  }

  // [OpenMP 5.0], 2.19.7.3. declare mapper Directive, Restrictions

  //  List-items in map clauses on this construct may only refer to the declared

  //  variable var and entities that could be referenced by a procedure defined

  //  at the same location.

  // [OpenMP 5.2] Also allow iterator declared variables.

  if (LangOpts.OpenMP && isa<VarDecl>(D) &&

      !isOpenMPDeclareMapperVarDeclAllowed(cast<VarDecl>(D))) {

    Diag(Loc, diag::err_omp_declare_mapper_wrong_var)

        << getOpenMPDeclareMapperVarName();

    Diag(D->getLocation(), diag::note_entity_declared_at) << D;

    return true;

  }

  if (const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {

    Diag(Loc, diag::err_use_of_empty_using_if_exists);

    Diag(EmptyD->getLocation(), diag::note_empty_using_if_exists_here);

    return true;

  }

  DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,

                             AvoidPartialAvailabilityChecks, ClassReceiver);

  DiagnoseUnusedOfDecl(*this, D, Loc);

  diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);

  if (D->hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {

    if (getLangOpts().getFPEvalMethod() !=

            LangOptions::FPEvalMethodKind::FEM_UnsetOnCommandLine &&

        PP.getLastFPEvalPragmaLocation().isValid() &&

        PP.getCurrentFPEvalMethod() != getLangOpts().getFPEvalMethod())

      Diag(D->getLocation(),

           diag::err_type_available_only_in_default_eval_method)

          << D->getName();

  }

  if (auto *VD = dyn_cast<ValueDecl>(D))

    checkTypeSupport(VD->getType(), Loc, VD);

  if (LangOpts.SYCLIsDevice ||

      (LangOpts.OpenMP && LangOpts.OpenMPIsTargetDevice)) {

    if (!Context.getTargetInfo().isTLSSupported())

      if (const auto *VD = dyn_cast<VarDecl>(D))

        if (VD->getTLSKind() != VarDecl::TLS_None)

          targetDiag(*Locs.begin(), diag::err_thread_unsupported);

  }

  if (isa<ParmVarDecl>(D) && isa<RequiresExprBodyDecl>(D->getDeclContext()) &&

      !isUnevaluatedContext()) {

    // C++ [expr.prim.req.nested] p3

    //   A local parameter shall only appear as an unevaluated operand

    //   (Clause 8) within the constraint-expression.

    Diag(Loc, diag::err_requires_expr_parameter_referenced_in_evaluated_context)

        << D;

    Diag(D->getLocation(), diag::note_entity_declared_at) << D;

    return true;

  }

  return false;

}

/// DiagnoseSentinelCalls - This routine checks whether a call or

/// message-send is to a declaration with the sentinel attribute, and

/// if so, it checks that the requirements of the sentinel are

/// satisfied.

void Sema::DiagnoseSentinelCalls(const 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 { CK_Function, CK_Method, CK_Block } CalleeKind;

  if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {

    NumFormalParams = MD->param_size();

    CalleeKind = CK_Method;

  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {

    NumFormalParams = FD->param_size();

    CalleeKind = CK_Function;

  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {

    QualType Ty = VD->getType();

    const FunctionType *Fn = nullptr;

    if (const auto *PtrTy = Ty->getAs<PointerType>()) {

      Fn = PtrTy->getPointeeType()->getAs<FunctionType>();

      if (!Fn)

        return;

      CalleeKind = CK_Function;

    } else if (const auto *PtrTy = Ty->getAs<BlockPointerType>()) {

      Fn = PtrTy->getPointeeType()->castAs<FunctionType>();

      CalleeKind = CK_Block;

    } else {

      return;

    }

    if (const auto *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");

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

    return;

  }

  // Otherwise, find the sentinel expression.

  const 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 (CalleeKind == CK_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(CalleeKind);

  else

    Diag(MissingNilLoc, diag::warn_missing_sentinel)

        << int(CalleeKind)

        << FixItHint::CreateInsertion(MissingNilLoc, ", " + NullValue);

  Diag(D->getLocation(), diag::note_sentinel_here)

      << int(CalleeKind) << Attr->getRange();

}

SourceRange Sema::getExprRange(Expr *E) const {

  return E ? E->getSourceRange() : SourceRange();

}

//===----------------------------------------------------------------------===//

//  Standard Promotions and Conversions

//===----------------------------------------------------------------------===//

/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).

ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {

  // Handle any placeholder expressions which made it here.

  if (E->hasPlaceholderType()) {

    ExprResult result = CheckPlaceholderExpr(E);

    if (result.isInvalid()) return ExprError();

    E = result.get();

  }

  QualType Ty = E->getType();

  assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");

  if (Ty->isFunctionType()) {

    if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))

      if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))

        if (!checkAddressOfFunctionIsAvailable(FD, Diagnose, E->getExprLoc()))

          return ExprError();

    E = ImpCastExprToType(E, Context.getPointerType(Ty),

                          CK_FunctionToPointerDecay).get();

  } else if (Ty->isArrayType()) {

    // In C90 mode, arrays only promote to pointers if the array expression is

    // an lvalue.  The relevant legalese is C90 6.2.2.1p3: "an lvalue that has

    // type 'array of type' is converted to an expression that has type 'pointer

    // to type'...".  In C99 this was changed to: C99 6.3.2.1p3: "an expression

    // that has type 'array of type' ...".  The relevant change is "an lvalue"

    // (C90) to "an expression" (C99).

    //

    // C++ 4.2p1:

    // An lvalue or rvalue of type "array of N T" or "array of unknown bound of

    // T" can be converted to an rvalue of type "pointer to T".

    //

    if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue()) {

      ExprResult Res = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),

                                         CK_ArrayToPointerDecay);

      if (Res.isInvalid())

        return ExprError();

      E = Res.get();

    }

  }

  return E;

}

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

    }

  }

}

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

      }

    }

}

ExprResult Sema::DefaultLvalueConversion(Expr *E) {

  // Handle any placeholder expressions which made it here.

  if (E->hasPlaceholderType()) {

    ExprResult result = CheckPlaceholderExpr(E);

    if (result.isInvalid()) return ExprError();

    E = result.get();

  }

  // C++ [conv.lval]p1:

  //   A glvalue of a non-function, non-array type T can be

  //   converted to a prvalue.

  if (!E->isGLValue()) return E;

  QualType T = E->getType();

  assert(!T.isNull() && "r-value conversion on typeless expression?");

  // lvalue-to-rvalue conversion cannot be applied to function or array types.

  if (T->isFunctionType() || T->isArrayType())

    return E;

  // We don't want to throw lvalue-to-rvalue casts on top of

  // expressions of certain types in C++.

  if (getLangOpts().CPlusPlus &&

      (E->getType() == Context.OverloadTy ||

       T->isDependentType() ||

       T->isRecordType()))

    return E;

  // The C standard is actually really unclear on this point, and

  // DR106 tells us what the result should be but not why.  It's

  // generally best to say that void types just doesn't undergo

  // lvalue-to-rvalue at all.  Note that expressions of unqualified

  // 'void' type are never l-values, but qualified void can be.

  if (T->isVoidType())

    return E;

  // OpenCL usually rejects direct accesses to values of 'half' type.

  if (getLangOpts().OpenCL &&

      !getOpenCLOptions().isAvailableOption("cl_khr_fp16", getLangOpts()) &&

      T->isHalfType()) {

    Diag(E->getExprLoc(), diag::err_opencl_half_load_store)

      << 0 << T;

    return ExprError();

  }

  CheckForNullPointerDereference(*this, E);

  if (const ObjCIsaExpr *OISA = dyn_cast<ObjCIsaExpr>(E->IgnoreParenCasts())) {

    NamedDecl *ObjectGetClass = LookupSingleName(TUScope,

                                     &Context.Idents.get("object_getClass"),

                                     SourceLocation(), LookupOrdinaryName);

    if (ObjectGetClass)

      Diag(E->getExprLoc(), diag::warn_objc_isa_use)

          << FixItHint::CreateInsertion(OISA->getBeginLoc(), "object_getClass(")

          << FixItHint::CreateReplacement(

                 SourceRange(OISA->getOpLoc(), OISA->getIsaMemberLoc()), ")");

    else

      Diag(E->getExprLoc(), diag::warn_objc_isa_use);

  }

  else if (const ObjCIvarRefExpr *OIRE =

            dyn_cast<ObjCIvarRefExpr>(E->IgnoreParenCasts()))

    DiagnoseDirectIsaAccess(*this, OIRE, SourceLocation(), /* Expr*/nullptr);

  // C++ [conv.lval]p1:

  //   [...] If T is a non-class type, the type of the prvalue is the

  //   cv-unqualified version of T. Otherwise, the type of the

  //   rvalue is T.

  //

  // C99 6.3.2.1p2:

  //   If the lvalue has qualified type, the value has the unqualified

  //   version of the type of the lvalue; otherwise, the value has the

  //   type of the lvalue.

  if (T.hasQualifiers())

    T = T.getUnqualifiedType();

  // Under the MS ABI, lock down the inheritance model now.

  if (T->isMemberPointerType() &&

      Context.getTargetInfo().getCXXABI().isMicrosoft())

    (void)isCompleteType(E->getExprLoc(), T);

  ExprResult Res = CheckLValueToRValueConversionOperand(E);

  if (Res.isInvalid())

    return Res;

  E = Res.get();

  // Loading a __weak object implicitly retains the value, so we need a cleanup to

  // balance that.

  if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)

    Cleanup.setExprNeedsCleanups(true);

  if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)

    Cleanup.setExprNeedsCleanups(true);

  // C++ [conv.lval]p3:

  //   If T is cv std::nullptr_t, the result is a null pointer constant.

  CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;

  Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_PRValue,

                                 CurFPFeatureOverrides());

  // C11 6.3.2.1p2:

  //   ... if the lvalue has atomic type, the value has the non-atomic version

  //   of the type of the lvalue ...

  if (const AtomicType *Atomic = T->getAs<AtomicType>()) {

    T = Atomic->getValueType().getUnqualifiedType();

    Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(),

                                   nullptr, VK_PRValue, FPOptionsOverride());

  }

  return Res;

}

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

}

/// CallExprUnaryConversions - a special case of an unary conversion

/// performed on a function designator of a call expression.

ExprResult Sema::CallExprUnaryConversions(Expr *E) {

  QualType Ty = E->getType();

  ExprResult Res = E;

  // Only do implicit cast for a function type, but not for a pointer

  // to function type.

  if (Ty->isFunctionType()) {

    Res = ImpCastExprToType(E, Context.getPointerType(Ty),

                            CK_FunctionToPointerDecay);

    if (Res.isInvalid())

      return ExprError();

  }

  Res = DefaultLvalueConversion(Res.get());

  if (Res.isInvalid())

    return ExprError();

  return Res.get();

}

/// UsualUnaryConversions - Performs various conversions that are common to most

/// operators (C99 6.3). The conversions of array and function types are

/// sometimes suppressed. For example, the array->pointer conversion doesn't

/// apply if the array is an argument to the sizeof or address (&) operators.

/// In these instances, this routine should *not* be called.

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

  LangOptions::FPEvalMethodKind EvalMethod = CurFPFeatures.getFPEvalMethod();

  if (EvalMethod != LangOptions::FEM_Source && Ty->isFloatingType() &&

      (getLangOpts().getFPEvalMethod() !=

           LangOptions::FPEvalMethodKind::FEM_UnsetOnCommandLine ||

       PP.getLastFPEvalPragmaLocation().isValid())) {

    switch (EvalMethod) {

    default:

      llvm_unreachable("Unrecognized float evaluation method");

      break;

    case LangOptions::FEM_UnsetOnCommandLine:

      llvm_unreachable("Float evaluation method should be set by now");

      break;

    case LangOptions::FEM_Double:

      if (Context.getFloatingTypeOrder(Context.DoubleTy, Ty) > 0)

        // Widen the expression to double.

        return Ty->isComplexType()

                   ? ImpCastExprToType(E,

                                       Context.getComplexType(Context.DoubleTy),

                                       CK_FloatingComplexCast)

                   : ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast);

      break;

    case LangOptions::FEM_Extended:

      if (Context.getFloatingTypeOrder(Context.LongDoubleTy, Ty) > 0)

        // Widen the expression to long double.

        return Ty->isComplexType()

                   ? ImpCastExprToType(

                         E, Context.getComplexType(Context.LongDoubleTy),

                         CK_FloatingComplexCast)

                   : ImpCastExprToType(E, Context.LongDoubleTy,

                                       CK_FloatingCast);

      break;

    }

  }

  // Half FP have to be promoted to float unless it is natively supported

  if (Ty->isHalfType() && !getLangOpts().NativeHalfType)

    return ImpCastExprToType(Res.get(), Context.FloatTy, CK_FloatingCast);

  // Try to perform integral promotions if the object has a theoretically

  // promotable type.

  if (Ty->isIntegralOrUnscopedEnumerationType()) {

    // C99 6.3.1.1p2:

    //

    //   The following may be used in an expression wherever an int or

    //   unsigned int may be used:

    //     - an object or expression with an integer type whose integer

    //       conversion rank is less than or equal to the rank of int

    //       and unsigned int.

    //     - A bit-field of type _Bool, int, signed int, or unsigned int.

    //

    //   If an int can represent all values of the original type, the

    //   value is converted to an int; otherwise, it is converted to an

    //   unsigned int. These are called the integer promotions. All

    //   other types are unchanged by the integer promotions.

    QualType PTy = Context.isPromotableBitField(E);

    if (!PTy.isNull()) {

      E = ImpCastExprToType(E, PTy, CK_IntegralCast).get();

      return E;

    }

    if (Context.isPromotableIntegerType(Ty)) {

      QualType PT = Context.getPromotedIntegerType(Ty);

      E = ImpCastExprToType(E, PT, CK_IntegralCast).get();

      return E;

    }

  }

  return E;

}

/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that

/// do not have a prototype. Arguments that have type float or __fp16

/// are promoted to double. All other argument types are converted by

/// UsualUnaryConversions().

ExprResult Sema::DefaultArgumentPromotion(Expr *E) {

  QualType Ty = E->getType();

  assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");

  ExprResult Res = UsualUnaryConversions(E);

  if (Res.isInvalid())

    return ExprError();

  E = Res.get();

  // If this is a 'float'  or '__fp16' (CVR qualified or typedef)

  // promote to double.

  // Note that default argument promotion applies only to float (and

  // half/fp16); it does not apply to _Float16.

  const BuiltinType *BTy = Ty->getAs<BuiltinType>();

  if (BTy && (BTy->getKind() == BuiltinType::Half ||

              BTy->getKind() == BuiltinType::Float)) {

    if (getLangOpts().OpenCL &&

        !getOpenCLOptions().isAvailableOption("cl_khr_fp64", getLangOpts())) {

      if (BTy->getKind() == BuiltinType::Half) {

        E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();

      }

    } else {

      E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();

    }

  }

  if (BTy &&

      getLangOpts().getExtendIntArgs() ==

          LangOptions::ExtendArgsKind::ExtendTo64 &&

      Context.getTargetInfo().supportsExtendIntArgs() && Ty->isIntegerType() &&

      Context.getTypeSizeInChars(BTy) <

          Context.getTypeSizeInChars(Context.LongLongTy)) {

    E = (Ty->isUnsignedIntegerType())

            ? ImpCastExprToType(E, Context.UnsignedLongLongTy, CK_IntegralCast)

                  .get()

            : ImpCastExprToType(E, Context.LongLongTy, CK_IntegralCast).get();

    assert(8 == Context.getTypeSizeInChars(Context.LongLongTy).getQuantity() &&

           "Unexpected typesize for LongLongTy");

  }

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