Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- Expr.h - Classes for representing expressions ----------*- C++ -*-===//

//

// 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 defines the Expr interface and subclasses.

//

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

#ifndef LLVM_CLANG_AST_EXPR_H

#define LLVM_CLANG_AST_EXPR_H

#include "clang/AST/APValue.h"

#include "clang/AST/ASTVector.h"

#include "clang/AST/ComputeDependence.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclAccessPair.h"

#include "clang/AST/DependenceFlags.h"

#include "clang/AST/OperationKinds.h"

#include "clang/AST/Stmt.h"

#include "clang/AST/TemplateBase.h"

#include "clang/AST/Type.h"

#include "clang/Basic/CharInfo.h"

#include "clang/Basic/LangOptions.h"

#include "clang/Basic/SyncScope.h"

#include "clang/Basic/TypeTraits.h"

#include "llvm/ADT/APFloat.h"

#include "llvm/ADT/APSInt.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/AtomicOrdering.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/TrailingObjects.h"

#include <optional>

namespace clang {

  class APValue;

  class ASTContext;

  class BlockDecl;

  class CXXBaseSpecifier;

  class CXXMemberCallExpr;

  class CXXOperatorCallExpr;

  class CastExpr;

  class Decl;

  class IdentifierInfo;

  class MaterializeTemporaryExpr;

  class NamedDecl;

  class ObjCPropertyRefExpr;

  class OpaqueValueExpr;

  class ParmVarDecl;

  class StringLiteral;

  class TargetInfo;

  class ValueDecl;

/// A simple array of base specifiers.

typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;

/// An adjustment to be made to the temporary created when emitting a

/// reference binding, which accesses a particular subobject of that temporary.

struct SubobjectAdjustment {

  enum {

    DerivedToBaseAdjustment,

    FieldAdjustment,

    MemberPointerAdjustment

  } Kind;

  struct DTB {

    const CastExpr *BasePath;

    const CXXRecordDecl *DerivedClass;

  };

  struct P {

    const MemberPointerType *MPT;

    Expr *RHS;

  };

  union {

    struct DTB DerivedToBase;

    FieldDecl *Field;

    struct P Ptr;

  };

  SubobjectAdjustment(const CastExpr *BasePath,

                      const CXXRecordDecl *DerivedClass)

    : Kind(DerivedToBaseAdjustment) {

    DerivedToBase.BasePath = BasePath;

    DerivedToBase.DerivedClass = DerivedClass;

  }

  SubobjectAdjustment(FieldDecl *Field)

    : Kind(FieldAdjustment) {

    this->Field = Field;

  }

  SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)

    : Kind(MemberPointerAdjustment) {

    this->Ptr.MPT = MPT;

    this->Ptr.RHS = RHS;

  }

};

/// This represents one expression.  Note that Expr's are subclasses of Stmt.

/// This allows an expression to be transparently used any place a Stmt is

/// required.

class Expr : public ValueStmt {

  QualType TR;

public:

  Expr() = delete;

  Expr(const Expr&) = delete;

  Expr(Expr &&) = delete;

  Expr &operator=(const Expr&) = delete;

  Expr &operator=(Expr&&) = delete;

protected:

  Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK)

      : ValueStmt(SC) {

    ExprBits.Dependent = 0;

    ExprBits.ValueKind = VK;

    ExprBits.ObjectKind = OK;

    assert(ExprBits.ObjectKind == OK && "truncated kind");

    setType(T);

  }

  /// Construct an empty expression.

  explicit Expr(StmtClass SC, EmptyShell) : ValueStmt(SC) { }

  /// Each concrete expr subclass is expected to compute its dependence and call

  /// this in the constructor.

  void setDependence(ExprDependence Deps) {

    ExprBits.Dependent = static_cast<unsigned>(Deps);

  }

  friend class ASTImporter; // Sets dependence dircetly.

  friend class ASTStmtReader; // Sets dependence dircetly.

public:

  QualType getType() const { return TR; }

  void setType(QualType t) {

    // In C++, the type of an expression is always adjusted so that it

    // will not have reference type (C++ [expr]p6). Use

    // QualType::getNonReferenceType() to retrieve the non-reference

    // type. Additionally, inspect Expr::isLvalue to determine whether

    // an expression that is adjusted in this manner should be

    // considered an lvalue.

    assert((t.isNull() || !t->isReferenceType()) &&

           "Expressions can't have reference type");

    TR = t;

  }

  ExprDependence getDependence() const {

    return static_cast<ExprDependence>(ExprBits.Dependent);

  }

  /// Determines whether the value of this expression depends on

  ///   - a template parameter (C++ [temp.dep.constexpr])

  ///   - or an error, whose resolution is unknown

  ///

  /// For example, the array bound of "Chars" in the following example is

  /// value-dependent.

  /// @code

  /// template<int Size, char (&Chars)[Size]> struct meta_string;

  /// @endcode

  bool isValueDependent() const {

    return static_cast<bool>(getDependence() & ExprDependence::Value);

  }

  /// Determines whether the type of this expression depends on

  ///   - a template paramter (C++ [temp.dep.expr], which means that its type

  ///     could change from one template instantiation to the next)

  ///   - or an error

  ///

  /// For example, the expressions "x" and "x + y" are type-dependent in

  /// the following code, but "y" is not type-dependent:

  /// @code

  /// template<typename T>

  /// void add(T x, int y) {

  ///   x + y;

  /// }

  /// @endcode

  bool isTypeDependent() const {

    return static_cast<bool>(getDependence() & ExprDependence::Type);

  }

  /// Whether this expression is instantiation-dependent, meaning that

  /// it depends in some way on

  ///    - a template parameter (even if neither its type nor (constant) value

  ///      can change due to the template instantiation)

  ///    - or an error

  ///

  /// In the following example, the expression \c sizeof(sizeof(T() + T())) is

  /// instantiation-dependent (since it involves a template parameter \c T), but

  /// is neither type- nor value-dependent, since the type of the inner

  /// \c sizeof is known (\c std::size_t) and therefore the size of the outer

  /// \c sizeof is known.

  ///

  /// \code

  /// template<typename T>

  /// void f(T x, T y) {

  ///   sizeof(sizeof(T() + T());

  /// }

  /// \endcode

  ///

  /// \code

  /// void func(int) {

  ///   func(); // the expression is instantiation-dependent, because it depends

  ///           // on an error.

  /// }

  /// \endcode

  bool isInstantiationDependent() const {

    return static_cast<bool>(getDependence() & ExprDependence::Instantiation);

  }

  /// Whether this expression contains an unexpanded parameter

  /// pack (for C++11 variadic templates).

  ///

  /// Given the following function template:

  ///

  /// \code

  /// template<typename F, typename ...Types>

  /// void forward(const F &f, Types &&...args) {

  ///   f(static_cast<Types&&>(args)...);

  /// }

  /// \endcode

  ///

  /// The expressions \c args and \c static_cast<Types&&>(args) both

  /// contain parameter packs.

  bool containsUnexpandedParameterPack() const {

    return static_cast<bool>(getDependence() & ExprDependence::UnexpandedPack);

  }

  /// Whether this expression contains subexpressions which had errors, e.g. a

  /// TypoExpr.

  bool containsErrors() const {

    return static_cast<bool>(getDependence() & ExprDependence::Error);

  }

  /// getExprLoc - Return the preferred location for the arrow when diagnosing

  /// a problem with a generic expression.

  SourceLocation getExprLoc() const LLVM_READONLY;

  /// Determine whether an lvalue-to-rvalue conversion should implicitly be

  /// applied to this expression if it appears as a discarded-value expression

  /// in C++11 onwards. This applies to certain forms of volatile glvalues.

  bool isReadIfDiscardedInCPlusPlus11() const;

  /// isUnusedResultAWarning - Return true if this immediate expression should

  /// be warned about if the result is unused.  If so, fill in expr, location,

  /// and ranges with expr to warn on and source locations/ranges appropriate

  /// for a warning.

  bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc,

                              SourceRange &R1, SourceRange &R2,

                              ASTContext &Ctx) const;

  /// isLValue - True if this expression is an "l-value" according to

  /// the rules of the current language.  C and C++ give somewhat

  /// different rules for this concept, but in general, the result of

  /// an l-value expression identifies a specific object whereas the

  /// result of an r-value expression is a value detached from any

  /// specific storage.

  ///

  /// C++11 divides the concept of "r-value" into pure r-values

  /// ("pr-values") and so-called expiring values ("x-values"), which

  /// identify specific objects that can be safely cannibalized for

  /// their resources.

  bool isLValue() const { return getValueKind() == VK_LValue; }

  bool isPRValue() const { return getValueKind() == VK_PRValue; }

  bool isXValue() const { return getValueKind() == VK_XValue; }

  bool isGLValue() const { return getValueKind() != VK_PRValue; }

  enum LValueClassification {

    LV_Valid,

    LV_NotObjectType,

    LV_IncompleteVoidType,

    LV_DuplicateVectorComponents,

    LV_InvalidExpression,

    LV_InvalidMessageExpression,

    LV_MemberFunction,

    LV_SubObjCPropertySetting,

    LV_ClassTemporary,

    LV_ArrayTemporary

  };

  /// Reasons why an expression might not be an l-value.

  LValueClassification ClassifyLValue(ASTContext &Ctx) const;

  enum isModifiableLvalueResult {

    MLV_Valid,

    MLV_NotObjectType,

    MLV_IncompleteVoidType,

    MLV_DuplicateVectorComponents,

    MLV_InvalidExpression,

    MLV_LValueCast,           // Specialized form of MLV_InvalidExpression.

    MLV_IncompleteType,

    MLV_ConstQualified,

    MLV_ConstQualifiedField,

    MLV_ConstAddrSpace,

    MLV_ArrayType,

    MLV_NoSetterProperty,

    MLV_MemberFunction,

    MLV_SubObjCPropertySetting,

    MLV_InvalidMessageExpression,

    MLV_ClassTemporary,

    MLV_ArrayTemporary

  };

  /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,

  /// does not have an incomplete type, does not have a const-qualified type,

  /// and if it is a structure or union, does not have any member (including,

  /// recursively, any member or element of all contained aggregates or unions)

  /// with a const-qualified type.

  ///

  /// \param Loc [in,out] - A source location which *may* be filled

  /// in with the location of the expression making this a

  /// non-modifiable lvalue, if specified.

  isModifiableLvalueResult

  isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc = nullptr) const;

  /// The return type of classify(). Represents the C++11 expression

  ///        taxonomy.

  class Classification {

  public:

    /// The various classification results. Most of these mean prvalue.

    enum Kinds {

      CL_LValue,

      CL_XValue,

      CL_Function, // Functions cannot be lvalues in C.

      CL_Void, // Void cannot be an lvalue in C.

      CL_AddressableVoid, // Void expression whose address can be taken in C.

      CL_DuplicateVectorComponents, // A vector shuffle with dupes.

      CL_MemberFunction, // An expression referring to a member function

      CL_SubObjCPropertySetting,

      CL_ClassTemporary, // A temporary of class type, or subobject thereof.

      CL_ArrayTemporary, // A temporary of array type.

      CL_ObjCMessageRValue, // ObjC message is an rvalue

      CL_PRValue // A prvalue for any other reason, of any other type

    };

    /// The results of modification testing.

    enum ModifiableType {

      CM_Untested, // testModifiable was false.

      CM_Modifiable,

      CM_RValue, // Not modifiable because it's an rvalue

      CM_Function, // Not modifiable because it's a function; C++ only

      CM_LValueCast, // Same as CM_RValue, but indicates GCC cast-as-lvalue ext

      CM_NoSetterProperty,// Implicit assignment to ObjC property without setter

      CM_ConstQualified,

      CM_ConstQualifiedField,

      CM_ConstAddrSpace,

      CM_ArrayType,

      CM_IncompleteType

    };

  private:

    friend class Expr;

    unsigned short Kind;

    unsigned short Modifiable;

    explicit Classification(Kinds k, ModifiableType m)

      : Kind(k), Modifiable(m)

    {}

  public:

    Classification() {}

    Kinds getKind() const { return static_cast<Kinds>(Kind); }

    ModifiableType getModifiable() const {

      assert(Modifiable != CM_Untested && "Did not test for modifiability.");

      return static_cast<ModifiableType>(Modifiable);

    }

    bool isLValue() const { return Kind == CL_LValue; }

    bool isXValue() const { return Kind == CL_XValue; }

    bool isGLValue() const { return Kind <= CL_XValue; }

    bool isPRValue() const { return Kind >= CL_Function; }

    bool isRValue() const { return Kind >= CL_XValue; }

    bool isModifiable() const { return getModifiable() == CM_Modifiable; }

    /// Create a simple, modifiably lvalue

    static Classification makeSimpleLValue() {

      return Classification(CL_LValue, CM_Modifiable);

    }

  };

  /// Classify - Classify this expression according to the C++11

  ///        expression taxonomy.

  ///

  /// C++11 defines ([basic.lval]) a new taxonomy of expressions to replace the

  /// old lvalue vs rvalue. This function determines the type of expression this

  /// is. There are three expression types:

  /// - lvalues are classical lvalues as in C++03.

  /// - prvalues are equivalent to rvalues in C++03.

  /// - xvalues are expressions yielding unnamed rvalue references, e.g. a

  ///   function returning an rvalue reference.

  /// lvalues and xvalues are collectively referred to as glvalues, while

  /// prvalues and xvalues together form rvalues.

  Classification Classify(ASTContext &Ctx) const {

    return ClassifyImpl(Ctx, nullptr);

  }

  /// ClassifyModifiable - Classify this expression according to the

  ///        C++11 expression taxonomy, and see if it is valid on the left side

  ///        of an assignment.

  ///

  /// This function extends classify in that it also tests whether the

  /// expression is modifiable (C99 6.3.2.1p1).

  /// \param Loc A source location that might be filled with a relevant location

  ///            if the expression is not modifiable.

  Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const{

    return ClassifyImpl(Ctx, &Loc);

  }

  /// Returns the set of floating point options that apply to this expression.

  /// Only meaningful for operations on floating point values.

  FPOptions getFPFeaturesInEffect(const LangOptions &LO) const;

  /// getValueKindForType - Given a formal return or parameter type,

  /// give its value kind.

  static ExprValueKind getValueKindForType(QualType T) {

    if (const ReferenceType *RT = T->getAs<ReferenceType>())

      return (isa<LValueReferenceType>(RT)

                ? VK_LValue

                : (RT->getPointeeType()->isFunctionType()

                     ? VK_LValue : VK_XValue));

    return VK_PRValue;

  }

  /// getValueKind - The value kind that this expression produces.

  ExprValueKind getValueKind() const {

    return static_cast<ExprValueKind>(ExprBits.ValueKind);

  }

  /// getObjectKind - The object kind that this expression produces.

  /// Object kinds are meaningful only for expressions that yield an

  /// l-value or x-value.

  ExprObjectKind getObjectKind() const {

    return static_cast<ExprObjectKind>(ExprBits.ObjectKind);

  }

  bool isOrdinaryOrBitFieldObject() const {

    ExprObjectKind OK = getObjectKind();

    return (OK == OK_Ordinary || OK == OK_BitField);

  }

  /// setValueKind - Set the value kind produced by this expression.

  void setValueKind(ExprValueKind Cat) { ExprBits.ValueKind = Cat; }

  /// setObjectKind - Set the object kind produced by this expression.

  void setObjectKind(ExprObjectKind Cat) { ExprBits.ObjectKind = Cat; }

private:

  Classification ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const;

public:

  /// Returns true if this expression is a gl-value that

  /// potentially refers to a bit-field.

  ///

  /// In C++, whether a gl-value refers to a bitfield is essentially

  /// an aspect of the value-kind type system.

  bool refersToBitField() const { return getObjectKind() == OK_BitField; }

  /// If this expression refers to a bit-field, retrieve the

  /// declaration of that bit-field.

  ///

  /// Note that this returns a non-null pointer in subtly different

  /// places than refersToBitField returns true.  In particular, this can

  /// return a non-null pointer even for r-values loaded from

  /// bit-fields, but it will return null for a conditional bit-field.

  FieldDecl *getSourceBitField();

  const FieldDecl *getSourceBitField() const {

    return const_cast<Expr*>(this)->getSourceBitField();

  }

  Decl *getReferencedDeclOfCallee();

  const Decl *getReferencedDeclOfCallee() const {

    return const_cast<Expr*>(this)->getReferencedDeclOfCallee();

  }

  /// If this expression is an l-value for an Objective C

  /// property, find the underlying property reference expression.

  const ObjCPropertyRefExpr *getObjCProperty() const;

  /// Check if this expression is the ObjC 'self' implicit parameter.

  bool isObjCSelfExpr() const;

  /// Returns whether this expression refers to a vector element.

  bool refersToVectorElement() const;

  /// Returns whether this expression refers to a matrix element.

  bool refersToMatrixElement() const {

    return getObjectKind() == OK_MatrixComponent;

  }

  /// Returns whether this expression refers to a global register

  /// variable.

  bool refersToGlobalRegisterVar() const;

  /// Returns whether this expression has a placeholder type.

  bool hasPlaceholderType() const {

    return getType()->isPlaceholderType();

  }

  /// Returns whether this expression has a specific placeholder type.

  bool hasPlaceholderType(BuiltinType::Kind K) const {

    assert(BuiltinType::isPlaceholderTypeKind(K));

    if (const BuiltinType *BT = dyn_cast<BuiltinType>(getType()))

      return BT->getKind() == K;

    return false;

  }

  /// isKnownToHaveBooleanValue - Return true if this is an integer expression

  /// that is known to return 0 or 1.  This happens for _Bool/bool expressions

  /// but also int expressions which are produced by things like comparisons in

  /// C.

  ///

  /// \param Semantic If true, only return true for expressions that are known

  /// to be semantically boolean, which might not be true even for expressions

  /// that are known to evaluate to 0/1. For instance, reading an unsigned

  /// bit-field with width '1' will evaluate to 0/1, but doesn't necessarily

  /// semantically correspond to a bool.

  bool isKnownToHaveBooleanValue(bool Semantic = true) const;

  /// Check whether this array fits the idiom of a flexible array member,

  /// depending on the value of -fstrict-flex-array.

  /// When IgnoreTemplateOrMacroSubstitution is set, it doesn't consider sizes

  /// resulting from the substitution of a macro or a template as special sizes.

  bool isFlexibleArrayMemberLike(

      ASTContext &Context,

      LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel,

      bool IgnoreTemplateOrMacroSubstitution = false) const;

  /// isIntegerConstantExpr - Return the value if this expression is a valid

  /// integer constant expression.  If not a valid i-c-e, return std::nullopt

  /// and fill in Loc (if specified) with the location of the invalid

  /// expression.

  ///

  /// Note: This does not perform the implicit conversions required by C++11

  /// [expr.const]p5.

  std::optional<llvm::APSInt>

  getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc = nullptr,

                         bool isEvaluated = true) const;

  bool isIntegerConstantExpr(const ASTContext &Ctx,

                             SourceLocation *Loc = nullptr) const;

  /// isCXX98IntegralConstantExpr - Return true if this expression is an

  /// integral constant expression in C++98. Can only be used in C++.

  bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const;

  /// isCXX11ConstantExpr - Return true if this expression is a constant

  /// expression in C++11. Can only be used in C++.

  ///

  /// Note: This does not perform the implicit conversions required by C++11

  /// [expr.const]p5.

  bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result = nullptr,

                           SourceLocation *Loc = nullptr) const;

  /// isPotentialConstantExpr - Return true if this function's definition

  /// might be usable in a constant expression in C++11, if it were marked

  /// constexpr. Return false if the function can never produce a constant

  /// expression, along with diagnostics describing why not.

  static bool isPotentialConstantExpr(const FunctionDecl *FD,

                                      SmallVectorImpl<

                                        PartialDiagnosticAt> &Diags);

  /// isPotentialConstantExprUnevaluted - Return true if this expression might

  /// be usable in a constant expression in C++11 in an unevaluated context, if

  /// it were in function FD marked constexpr. Return false if the function can

  /// never produce a constant expression, along with diagnostics describing

  /// why not.

  static bool isPotentialConstantExprUnevaluated(Expr *E,

                                                 const FunctionDecl *FD,

                                                 SmallVectorImpl<

                                                   PartialDiagnosticAt> &Diags);

  /// isConstantInitializer - Returns true if this expression can be emitted to

  /// IR as a constant, and thus can be used as a constant initializer in C.

  /// If this expression is not constant and Culprit is non-null,

  /// it is used to store the address of first non constant expr.

  bool isConstantInitializer(ASTContext &Ctx, bool ForRef,

                             const Expr **Culprit = nullptr) const;

  /// If this expression is an unambiguous reference to a single declaration,

  /// in the style of __builtin_function_start, return that declaration.  Note

  /// that this may return a non-static member function or field in C++ if this

  /// expression is a member pointer constant.

  const ValueDecl *getAsBuiltinConstantDeclRef(const ASTContext &Context) const;

  /// EvalStatus is a struct with detailed info about an evaluation in progress.

  struct EvalStatus {

    /// Whether the evaluated expression has side effects.

    /// For example, (f() && 0) can be folded, but it still has side effects.

    bool HasSideEffects;

    /// Whether the evaluation hit undefined behavior.

    /// For example, 1.0 / 0.0 can be folded to Inf, but has undefined behavior.

    /// Likewise, INT_MAX + 1 can be folded to INT_MIN, but has UB.

    bool HasUndefinedBehavior;

    /// Diag - If this is non-null, it will be filled in with a stack of notes

    /// indicating why evaluation failed (or why it failed to produce a constant

    /// expression).

    /// If the expression is unfoldable, the notes will indicate why it's not

    /// foldable. If the expression is foldable, but not a constant expression,

    /// the notes will describes why it isn't a constant expression. If the

    /// expression *is* a constant expression, no notes will be produced.

    SmallVectorImpl<PartialDiagnosticAt> *Diag;

    EvalStatus()

        : HasSideEffects(false), HasUndefinedBehavior(false), Diag(nullptr) {}

    // hasSideEffects - Return true if the evaluated expression has

    // side effects.

    bool hasSideEffects() const {

      return HasSideEffects;

    }

  };

  /// EvalResult is a struct with detailed info about an evaluated expression.

  struct EvalResult : EvalStatus {

    /// Val - This is the value the expression can be folded to.

    APValue Val;

    // isGlobalLValue - Return true if the evaluated lvalue expression

    // is global.

    bool isGlobalLValue() const;

  };

  /// EvaluateAsRValue - Return true if this is a constant which we can fold to

  /// an rvalue using any crazy technique (that has nothing to do with language

  /// standards) that we want to, even if the expression has side-effects. If

  /// this function returns true, it returns the folded constant in Result. If

  /// the expression is a glvalue, an lvalue-to-rvalue conversion will be

  /// applied.

  bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,

                        bool InConstantContext = false) const;

  /// EvaluateAsBooleanCondition - Return true if this is a constant

  /// which we can fold and convert to a boolean condition using

  /// any crazy technique that we want to, even if the expression has

  /// side-effects.

  bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,

                                  bool InConstantContext = false) const;

  enum SideEffectsKind {

    SE_NoSideEffects,          ///< Strictly evaluate the expression.

    SE_AllowUndefinedBehavior, ///< Allow UB that we can give a value, but not

                               ///< arbitrary unmodeled side effects.

    SE_AllowSideEffects        ///< Allow any unmodeled side effect.

  };

  /// EvaluateAsInt - Return true if this is a constant which we can fold and

  /// convert to an integer, using any crazy technique that we want to.

  bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,

                     SideEffectsKind AllowSideEffects = SE_NoSideEffects,

                     bool InConstantContext = false) const;

  /// EvaluateAsFloat - Return true if this is a constant which we can fold and

  /// convert to a floating point value, using any crazy technique that we

  /// want to.

  bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx,

                       SideEffectsKind AllowSideEffects = SE_NoSideEffects,

                       bool InConstantContext = false) const;

  /// EvaluateAsFloat - Return true if this is a constant which we can fold and

  /// convert to a fixed point value.

  bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,

                            SideEffectsKind AllowSideEffects = SE_NoSideEffects,

                            bool InConstantContext = false) const;

  /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be

  /// constant folded without side-effects, but discard the result.

  bool isEvaluatable(const ASTContext &Ctx,

                     SideEffectsKind AllowSideEffects = SE_NoSideEffects) const;

  /// HasSideEffects - This routine returns true for all those expressions

  /// which have any effect other than producing a value. Example is a function

  /// call, volatile variable read, or throwing an exception. If

  /// IncludePossibleEffects is false, this call treats certain expressions with

  /// potential side effects (such as function call-like expressions,

  /// instantiation-dependent expressions, or invocations from a macro) as not

  /// having side effects.

  bool HasSideEffects(const ASTContext &Ctx,

                      bool IncludePossibleEffects = true) const;

  /// Determine whether this expression involves a call to any function

  /// that is not trivial.

  bool hasNonTrivialCall(const ASTContext &Ctx) const;

  /// EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded

  /// integer. This must be called on an expression that constant folds to an

  /// integer.

  llvm::APSInt EvaluateKnownConstInt(

      const ASTContext &Ctx,

      SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

  llvm::APSInt EvaluateKnownConstIntCheckOverflow(

      const ASTContext &Ctx,

      SmallVectorImpl<PartialDiagnosticAt> *Diag = nullptr) const;

  void EvaluateForOverflow(const ASTContext &Ctx) const;

  /// EvaluateAsLValue - Evaluate an expression to see if we can fold it to an

  /// lvalue with link time known address, with no side-effects.

  bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,

                        bool InConstantContext = false) const;

  /// EvaluateAsInitializer - Evaluate an expression as if it were the

  /// initializer of the given declaration. Returns true if the initializer

  /// can be folded to a constant, and produces any relevant notes. In C++11,

  /// notes will be produced if the expression is not a constant expression.

  bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx,

                             const VarDecl *VD,

                             SmallVectorImpl<PartialDiagnosticAt> &Notes,

                             bool IsConstantInitializer) const;

  /// EvaluateWithSubstitution - Evaluate an expression as if from the context

  /// of a call to the given function with the given arguments, inside an

  /// unevaluated context. Returns true if the expression could be folded to a

  /// constant.

  bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,

                                const FunctionDecl *Callee,

                                ArrayRef<const Expr*> Args,

                                const Expr *This = nullptr) const;

  enum class ConstantExprKind {

    /// An integer constant expression (an array bound, enumerator, case value,

    /// bit-field width, or similar) or similar.

    Normal,

    /// A non-class template argument. Such a value is only used for mangling,

    /// not for code generation, so can refer to dllimported functions.

    NonClassTemplateArgument,

    /// A class template argument. Such a value is used for code generation.

    ClassTemplateArgument,

    /// An immediate invocation. The destruction of the end result of this

    /// evaluation is not part of the evaluation, but all other temporaries

    /// are destroyed.

    ImmediateInvocation,

  };

  /// Evaluate an expression that is required to be a constant expression. Does

  /// not check the syntactic constraints for C and C++98 constant expressions.

  bool EvaluateAsConstantExpr(

      EvalResult &Result, const ASTContext &Ctx,

      ConstantExprKind Kind = ConstantExprKind::Normal) const;

  /// If the current Expr is a pointer, this will try to statically

  /// determine the number of bytes available where the pointer is pointing.

  /// Returns true if all of the above holds and we were able to figure out the

  /// size, false otherwise.

  ///

  /// \param Type - How to evaluate the size of the Expr, as defined by the

  /// "type" parameter of __builtin_object_size

  bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx,

                             unsigned Type) const;

  /// If the current Expr is a pointer, this will try to statically

  /// determine the strlen of the string pointed to.

  /// Returns true if all of the above holds and we were able to figure out the

  /// strlen, false otherwise.

  bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const;

  /// Enumeration used to describe the kind of Null pointer constant

  /// returned from \c isNullPointerConstant().

  enum NullPointerConstantKind {

    /// Expression is not a Null pointer constant.

    NPCK_NotNull = 0,

    /// Expression is a Null pointer constant built from a zero integer

    /// expression that is not a simple, possibly parenthesized, zero literal.

    /// C++ Core Issue 903 will classify these expressions as "not pointers"

    /// once it is adopted.

    /// http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903

    NPCK_ZeroExpression,

    /// Expression is a Null pointer constant built from a literal zero.

    NPCK_ZeroLiteral,

    /// Expression is a C++11 nullptr.

    NPCK_CXX11_nullptr,

    /// Expression is a GNU-style __null constant.

    NPCK_GNUNull

  };

  /// Enumeration used to describe how \c isNullPointerConstant()

  /// should cope with value-dependent expressions.

  enum NullPointerConstantValueDependence {

    /// Specifies that the expression should never be value-dependent.

    NPC_NeverValueDependent = 0,

    /// Specifies that a value-dependent expression of integral or

    /// dependent type should be considered a null pointer constant.

    NPC_ValueDependentIsNull,

    /// Specifies that a value-dependent expression should be considered

    /// to never be a null pointer constant.

    NPC_ValueDependentIsNotNull

  };

  /// isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to

  /// a Null pointer constant. The return value can further distinguish the

  /// kind of NULL pointer constant that was detected.

  NullPointerConstantKind isNullPointerConstant(

      ASTContext &Ctx,

      NullPointerConstantValueDependence NPC) const;

  /// isOBJCGCCandidate - Return true if this expression may be used in a read/

  /// write barrier.

  bool isOBJCGCCandidate(ASTContext &Ctx) const;

  /// Returns true if this expression is a bound member function.

  bool isBoundMemberFunction(ASTContext &Ctx) const;

  /// Given an expression of bound-member type, find the type

  /// of the member.  Returns null if this is an *overloaded* bound

  /// member expression.

  static QualType findBoundMemberType(const Expr *expr);

  /// Skip past any invisble AST nodes which might surround this

  /// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,

  /// but also injected CXXMemberExpr and CXXConstructExpr which represent

  /// implicit conversions.

  Expr *IgnoreUnlessSpelledInSource();

  const Expr *IgnoreUnlessSpelledInSource() const {

    return const_cast<Expr *>(this)->IgnoreUnlessSpelledInSource();

  }

  /// Skip past any implicit casts which might surround this expression until

  /// reaching a fixed point. Skips:

  /// * ImplicitCastExpr

  /// * FullExpr

  Expr *IgnoreImpCasts() LLVM_READONLY;

  const Expr *IgnoreImpCasts() const {

    return const_cast<Expr *>(this)->IgnoreImpCasts();

  }

  /// Skip past any casts which might surround this expression until reaching

  /// a fixed point. Skips:

  /// * CastExpr

  /// * FullExpr

  /// * MaterializeTemporaryExpr

  /// * SubstNonTypeTemplateParmExpr

  Expr *IgnoreCasts() LLVM_READONLY;

  const Expr *IgnoreCasts() const {

    return const_cast<Expr *>(this)->IgnoreCasts();

  }

  /// Skip past any implicit AST nodes which might surround this expression

  /// until reaching a fixed point. Skips:

  /// * What IgnoreImpCasts() skips

  /// * MaterializeTemporaryExpr

  /// * CXXBindTemporaryExpr

  Expr *IgnoreImplicit() LLVM_READONLY;

  const Expr *IgnoreImplicit() const {

    return const_cast<Expr *>(this)->IgnoreImplicit();

  }

  /// Skip past any implicit AST nodes which might surround this expression

  /// until reaching a fixed point. Same as IgnoreImplicit, except that it

  /// also skips over implicit calls to constructors and conversion functions.

  ///

  /// FIXME: Should IgnoreImplicit do this?

  Expr *IgnoreImplicitAsWritten() LLVM_READONLY;

  const Expr *IgnoreImplicitAsWritten() const {

    return const_cast<Expr *>(this)->IgnoreImplicitAsWritten();

  }

  /// Skip past any parentheses which might surround this expression until

  /// reaching a fixed point. Skips:

  /// * ParenExpr

  /// * UnaryOperator if `UO_Extension`