//===--- 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/RecursiveASTVisitor.h"

#include "clang/AST/TypeLoc.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/SourceManager.h"

#include "clang/Basic/TargetInfo.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/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/ConvertUTF.h"

#include "llvm/Support/SaveAndRestore.h"

using namespace clang;

using namespace sema;

using llvm::RoundingMode;

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

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

      return false;

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

    // unavailable.

    if (TreatUnavailableAsInvalid &&

        
isUnavailableAlignedAllocationFunction(*FD)0
)

      return false;

  }

  // See if this function is unavailable.

  if (TreatUnavailableAsInvalid && 
D->getAvailability() == AR_Unavailable17.5k
 &&

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

    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::C2x_maybe_unused108k
) {

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

    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() != 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 && 
UsedFn6.75k
)

    DowngradeWarning = UsedFn->isInlined() || 
UsedFn->hasAttr<ConstAttr>()19
;

  S.Diag(Loc, DowngradeWarning ? 
diag::ext_internal_in_extern_inline_quiet6.74k

                               : 
diag::ext_internal_in_extern_inline22
)

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

  SourceLocation Loc = Locs.front();

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

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

        Diag(Loc, diag::err_deleted_inherited_ctor_use)

            << Ctor->getParent()

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

      else

        Diag(Loc, diag::err_deleted_function_use);

      NoteDeletedFunction(FD);

      return true;

    }

    // [expr.prim.id]p4

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

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

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

    //

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

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

    // definition.

    if (FD->getTrailingRequiresClause()) {

      ConstraintSatisfaction Satisfaction;

      if (CheckFunctionConstraints(FD, Satisfaction, Loc))

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

        // constraint expression, for example)

        return true;

      if (!Satisfaction.IsSatisfied) {

        Diag(Loc,

             diag::err_reference_to_function_with_unsatisfied_constraints)

            << D;

        DiagnoseUnsatisfiedConstraint(Satisfaction);

        return true;

      }

    }

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

    // then we can't use it either.

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

        
DeduceReturnType(FD, Loc)2.27k
)

      return true;

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

      return true;

    if (getLangOpts().SYCLIsDevice && 
!checkSYCLDeviceFunction(Loc, FD)391
)

      return true;

  }

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

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

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

        
(20.0k
(20.0k
isa<CXXConstructorDecl>(MD)20.0k
 &&

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

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

      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 && 
DRD1.75M
 && 
!CurContext->containsDecl(D)1.94k
 &&

      
isa<VarDecl>(D)349
) {

    Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)

        << getCurFunction()->HasOMPDeclareReductionCombiner;

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

    return true;

  }

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

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

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

  //  at the same location

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

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

    Diag(Loc, diag::err_omp_declare_mapper_wrong_var)

        << getOpenMPDeclareMapperVarName();

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

    return true;

  }

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

    Diag(Loc, diag::err_use_of_empty_using_if_exists);

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

    return true;

  }

  DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,

                             AvoidPartialAvailabilityChecks, ClassReceiver);

  DiagnoseUnusedOfDecl(*this, D, Loc);

  diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);

  if (LangOpts.SYCLIsDevice || 
(153M
LangOpts.OpenMP153M
 && 
LangOpts.OpenMPIsDevice1.75M
)) {

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

      checkDeviceDecl(VD, Loc);

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

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

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

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

  }

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

      
!isUnevaluatedContext()189
) {

    // 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(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 *39
FD39
 = dyn_cast<FunctionDecl>(D)) {

    numFormalParams = FD->param_size();

    calleeType = CT_Function;

  } else 
if (12
isa<VarDecl>(D)12
) {

    QualType type = cast<ValueDecl>(D)->getType();

    const FunctionType *fn = nullptr;

    if (const PointerType *ptr = type->getAs<PointerType>()) {

      fn = ptr->getPointeeType()->getAs<FunctionType>();

      if (!fn) 
return0
;

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

  numFormalParams = (nullPos > numFormalParams ? 
00
 : 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) 
return0
;

  if (sentinelExpr->isValueDependent()) 
return0
;

  if (Context.isSentinelNullExpr(sentinelExpr)) 
return245
;

  // 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")5
)

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

}

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

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

}

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

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

    ExprResult result = CheckPlaceholderExpr(E);

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

    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().CPlusPlus76.7k
 || 
E->isLValue()1.24k
) {

      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_Deref103k
 &&

      
UO->getSubExpr()->getType()->isPointerType()91.3k
) {

    const LangAS AS =

        UO->getSubExpr()->getType()->getPointeeType().getAddressSpace();

    if ((!isTargetAddressSpace(AS) ||

         
(15
isTargetAddressSpace(AS)15
 && 
toTargetAddressSpace(AS) == 015
)) &&

        UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(

            S.Context, Expr::NPC_ValueDependentIsNotNull) &&

        
!UO->getType().isVolatileQualified()1.12k
) {

      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()) == IV16
) {

        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->getType()->isPlaceholderType()) {

    ExprResult result = CheckPlaceholderExpr(E);

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

    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 E27.2M
;

  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()13.2M
)

    return E;

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

  // expressions of certain types in C++.

  if (getLangOpts().CPlusPlus &&

      
(5.48M
E->getType() == Context.OverloadTy5.48M
 ||

       T->isDependentType() ||

       
T->isRecordType()5.48M
))

    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())668k
 &&

      
T->isHalfType()6.22k
) {

    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()1.11k
)

    (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_NullToPointer1.15k
 : 
CK_LValueToRValue13.2M
;

  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()9.48M
) {

    switch (EvalMethod) {

    default:

      llvm_unreachable("Unrecognized float evaluation method");

      break;

    case LangOptions::FEM_TargetDefault:

      // Float evaluation method not defined, use FEM_Source.

      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().NativeHalfType1.47k
)

    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;

}

/// 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 && 
(91.2k
BTy->getKind() == BuiltinType::Half91.2k
 ||

              
BTy->getKind() == BuiltinType::Float91.2k
)) {

    if (getLangOpts().OpenCL &&

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

      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()46
 && 
Ty->isIntegerType()16
 &&

      Context.getTypeSizeInChars(BTy) <

          Context.getTypeSizeInChars(Context.LongLongTy)) {

    E = (Ty->isUnsignedIntegerType())

            ? ImpCastExprToType(E, Context.UnsignedLongLongTy, CK_IntegralCast)

                  .get()

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

    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()105k
 && 
!isUnevaluatedContext()249
) {

    ExprResult Temp = PerformCopyInitialization(

                       InitializedEntity::InitializeTemporary(E->getType()),

                                                E->getExprLoc(), E);

    if (Temp.isInvalid())

      return ExprError();

    E = Temp.get();

  }

  return E;

}

/// Determine the degree of POD-ness for an expression.

/// Incomplete types are considered POD, since this check can be performed

/// when we're in an unevaluated context.

Sema::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()341
)

    if (CXXRecordDecl *Record = Ty->getAsCXXRecordDecl())

      if (!Record->hasNonTrivialCopyConstructor() &&

          
!Record->hasNonTrivialMoveConstructor()281
 &&

          
!Record->hasNonTrivialDestructor()281
)

        return VAK_ValidInCXX11;

  if (getLangOpts().ObjCAutoRefCount && 
Ty->isObjCLifetimeType()0
)

    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;

}

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

  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;

  }

}

/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but

/// will create a trap if the resulting type is not a POD type.

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

        
(9
CT == VariadicMethod9
 ||

         
(7
FDecl7
 && 
FDecl->hasAttr<CFAuditedTransferAttr>()7
))) {

      E = stripARCUnbridgedCast(E);

    // Otherwise, do normal placeholder checking.

    } else {

      ExprResult ExprRes = CheckPlaceholderExpr(E);

      if (ExprRes.isInvalid())

        return ExprError();

      E = ExprRes.get();