Commit ddd20ed1 authored by Ilya Biryukov's avatar Ilya Biryukov Committed by Haojian Wu
Browse files

[AST] Move dependence computations into a separate file 

To group the code in one place, simplify it and make it easier to add
the containsErrors bit and find existing bugs.
parent 88fbd8f9

clang/include/clang/AST/ComputeDependence.h

0 → 100644
+182 −0
Original line number Diff line number Diff line 
//===--- ComputeDependence.h -------------------------------------- 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

//

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

//

//  Calculate various template dependency flags for the AST.

//

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



#ifndef LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H

#define LLVM_CLANG_AST_COMPUTE_DEPENDENCE_H



#include "clang/AST/DependenceFlags.h"

#include "clang/Basic/ExceptionSpecificationType.h"

#include "llvm/ADT/ArrayRef.h"



namespace clang {



class ASTContext;



class Expr;

class FullExpr;

class OpaqueValueExpr;

class ParenExpr;

class UnaryOperator;

class UnaryExprOrTypeTraitExpr;

class ArraySubscriptExpr;

class CompoundLiteralExpr;

class CastExpr;

class BinaryOperator;

class ConditionalOperator;

class BinaryConditionalOperator;

class StmtExpr;

class ConvertVectorExpr;

class VAArgExpr;

class ChooseExpr;

class NoInitExpr;

class ArrayInitLoopExpr;

class ImplicitValueInitExpr;

class InitListExpr;

class ExtVectorElementExpr;

class BlockExpr;

class AsTypeExpr;

class DeclRefExpr;

class CXXRewrittenBinaryOperator;

class CXXStdInitializerListExpr;

class CXXTypeidExpr;

class MSPropertyRefExpr;

class MSPropertySubscriptExpr;

class CXXUuidofExpr;

class CXXThisExpr;

class CXXThrowExpr;

class CXXBindTemporaryExpr;

class CXXScalarValueInitExpr;

class CXXDeleteExpr;

class ArrayTypeTraitExpr;

class ExpressionTraitExpr;

class CXXNoexceptExpr;

class SubstNonTypeTemplateParmExpr;

class CoroutineSuspendExpr;

class DependentCoawaitExpr;

class CXXNewExpr;

class CXXPseudoDestructorExpr;

class OverloadExpr;

class DependentScopeDeclRefExpr;

class CXXConstructExpr;

class LambdaExpr;

class CXXUnresolvedConstructExpr;

class CXXDependentScopeMemberExpr;

class MaterializeTemporaryExpr;

class TypeTraitExpr;

class ConceptSpecializationExpr;

class PredefinedExpr;

class CallExpr;

class OffsetOfExpr;

class MemberExpr;

class ShuffleVectorExpr;

class GenericSelectionExpr;

class DesignatedInitExpr;

class ParenListExpr;

class PseudoObjectExpr;

class AtomicExpr;

class OMPArraySectionExpr;

class ObjCArrayLiteral;

class ObjCDictionaryLiteral;

class ObjCBoxedExpr;

class ObjCEncodeExpr;

class ObjCIvarRefExpr;

class ObjCPropertyRefExpr;

class ObjCSubscriptRefExpr;

class ObjCIsaExpr;

class ObjCIndirectCopyRestoreExpr;

class ObjCMessageExpr;



// The following functions are called from constructors of `Expr`, so they

// should not access anything beyond basic

ExprDependence computeDependence(FullExpr *E);

ExprDependence computeDependence(OpaqueValueExpr *E);

ExprDependence computeDependence(ParenExpr *E);

ExprDependence computeDependence(UnaryOperator *E);

ExprDependence computeDependence(UnaryExprOrTypeTraitExpr *E);

ExprDependence computeDependence(ArraySubscriptExpr *E);

ExprDependence computeDependence(CompoundLiteralExpr *E);

ExprDependence computeDependence(CastExpr *E);

ExprDependence computeDependence(BinaryOperator *E);

ExprDependence computeDependence(ConditionalOperator *E);

ExprDependence computeDependence(BinaryConditionalOperator *E);

ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth);

ExprDependence computeDependence(ConvertVectorExpr *E);

ExprDependence computeDependence(VAArgExpr *E);

ExprDependence computeDependence(ChooseExpr *E);

ExprDependence computeDependence(NoInitExpr *E);

ExprDependence computeDependence(ArrayInitLoopExpr *E);

ExprDependence computeDependence(ImplicitValueInitExpr *E);

ExprDependence computeDependence(InitListExpr *E);

ExprDependence computeDependence(ExtVectorElementExpr *E);

ExprDependence computeDependence(BlockExpr *E);

ExprDependence computeDependence(AsTypeExpr *E);

ExprDependence computeDependence(DeclRefExpr *E, const ASTContext &Ctx);

ExprDependence computeDependence(CXXRewrittenBinaryOperator *E);

ExprDependence computeDependence(CXXStdInitializerListExpr *E);

ExprDependence computeDependence(CXXTypeidExpr *E);

ExprDependence computeDependence(MSPropertyRefExpr *E);

ExprDependence computeDependence(MSPropertySubscriptExpr *E);

ExprDependence computeDependence(CXXUuidofExpr *E);

ExprDependence computeDependence(CXXThisExpr *E);

ExprDependence computeDependence(CXXThrowExpr *E);

ExprDependence computeDependence(CXXBindTemporaryExpr *E);

ExprDependence computeDependence(CXXScalarValueInitExpr *E);

ExprDependence computeDependence(CXXDeleteExpr *E);

ExprDependence computeDependence(ArrayTypeTraitExpr *E);

ExprDependence computeDependence(ExpressionTraitExpr *E);

ExprDependence computeDependence(CXXNoexceptExpr *E, CanThrowResult CT);

ExprDependence computeDependence(SubstNonTypeTemplateParmExpr *E);

ExprDependence computeDependence(CoroutineSuspendExpr *E);

ExprDependence computeDependence(DependentCoawaitExpr *E);

ExprDependence computeDependence(CXXNewExpr *E);

ExprDependence computeDependence(CXXPseudoDestructorExpr *E);

ExprDependence computeDependence(OverloadExpr *E, bool KnownDependent,

                                 bool KnownInstantiationDependent,

                                 bool KnownContainsUnexpandedParameterPack);

ExprDependence computeDependence(DependentScopeDeclRefExpr *E);

ExprDependence computeDependence(CXXConstructExpr *E);

ExprDependence computeDependence(LambdaExpr *E,

                                 bool ContainsUnexpandedParameterPack);

ExprDependence computeDependence(CXXUnresolvedConstructExpr *E);

ExprDependence computeDependence(CXXDependentScopeMemberExpr *E);

ExprDependence computeDependence(MaterializeTemporaryExpr *E);

ExprDependence computeDependence(TypeTraitExpr *E);

ExprDependence computeDependence(ConceptSpecializationExpr *E,

                                 bool ValueDependent);



ExprDependence computeDependence(PredefinedExpr *E);

ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef<Expr *> PreArgs);

ExprDependence computeDependence(OffsetOfExpr *E);

ExprDependence computeDependence(MemberExpr *E);

ExprDependence computeDependence(ShuffleVectorExpr *E);

ExprDependence computeDependence(GenericSelectionExpr *E,

                                 bool ContainsUnexpandedPack);

ExprDependence computeDependence(DesignatedInitExpr *E);

ExprDependence computeDependence(ParenListExpr *E);

ExprDependence computeDependence(PseudoObjectExpr *E);

ExprDependence computeDependence(AtomicExpr *E);



ExprDependence computeDependence(OMPArraySectionExpr *E);



ExprDependence computeDependence(ObjCArrayLiteral *E);

ExprDependence computeDependence(ObjCDictionaryLiteral *E);

ExprDependence computeDependence(ObjCBoxedExpr *E);

ExprDependence computeDependence(ObjCEncodeExpr *E);

ExprDependence computeDependence(ObjCIvarRefExpr *E);

ExprDependence computeDependence(ObjCPropertyRefExpr *E);

ExprDependence computeDependence(ObjCSubscriptRefExpr *E);

ExprDependence computeDependence(ObjCIsaExpr *E);

ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);

ExprDependence computeDependence(ObjCMessageExpr *E);



} // namespace clang

#endif

clang/include/clang/AST/DependenceFlags.h

+7 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ struct ExprDependenceScope { 
    None = 0,

    All = 15,



    TypeValue = Type | Value,

    TypeInstantiation = Type | Instantiation,

    ValueInstantiation = Value | Instantiation,

    TypeValueInstantiation = Type | Value | Instantiation,
@@ -94,6 +95,12 @@ inline ExprDependence toExprDependence(TypeDependence TD) { 
  return toExprDependence(static_cast<TemplateArgumentDependence>(

      TD & ~TypeDependence::VariablyModified));

}

inline ExprDependence toExprDependence(NestedNameSpecifierDependence NSD) {

  // This hack works because TypeDependence and TemplateArgumentDependence

  // share the same bit representation.

  return toExprDependence(static_cast<TemplateArgumentDependence>(NSD)) &

         ~ExprDependence::TypeValue;

}

inline ExprDependence turnTypeToValueDependence(ExprDependence D) {

  // Type-dependent expressions are always be value-dependent, so we simply drop

  // type dependency.

clang/include/clang/AST/Expr.h

+121 −226

File changed.

Preview size limit exceeded, changes collapsed.

clang/include/clang/AST/ExprCXX.h

+91 −131

File changed.

Preview size limit exceeded, changes collapsed.

clang/include/clang/AST/ExprObjC.h

+78 −90
Original line number Diff line number Diff line
@@ -13,8 +13,10 @@ 
#ifndef LLVM_CLANG_AST_EXPROBJC_H

#define LLVM_CLANG_AST_EXPROBJC_H



#include "clang/AST/ComputeDependence.h"

#include "clang/AST/Decl.h"

#include "clang/AST/DeclObjC.h"

#include "clang/AST/DependenceFlags.h"

#include "clang/AST/Expr.h"

#include "clang/AST/OperationKinds.h"

#include "clang/AST/SelectorLocationsKind.h"
@@ -53,9 +55,10 @@ class ObjCStringLiteral : public Expr { 


public:

  ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)

      : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary, false, false,

             false, false),

        String(SL), AtLoc(L) {}

      : Expr(ObjCStringLiteralClass, T, VK_RValue, OK_Ordinary), String(SL),

        AtLoc(L) {

    setDependence(ExprDependence::None);

  }

  explicit ObjCStringLiteral(EmptyShell Empty)

      : Expr(ObjCStringLiteralClass, Empty) {}
@@ -88,9 +91,10 @@ class ObjCBoolLiteralExpr : public Expr { 


public:

  ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)

      : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary, false, false,

             false, false),

        Value(val), Loc(l) {}

      : Expr(ObjCBoolLiteralExprClass, Ty, VK_RValue, OK_Ordinary), Value(val),

        Loc(l) {

    setDependence(ExprDependence::None);

  }

  explicit ObjCBoolLiteralExpr(EmptyShell Empty)

      : Expr(ObjCBoolLiteralExprClass, Empty) {}
@@ -129,13 +133,11 @@ class ObjCBoxedExpr : public Expr { 
public:

  friend class ASTStmtReader;



  ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method,

                     SourceRange R)

      : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary,

             E->isTypeDependent(), E->isValueDependent(),

             E->isInstantiationDependent(),

             E->containsUnexpandedParameterPack()),

        SubExpr(E), BoxingMethod(method), Range(R) {}

  ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R)

      : Expr(ObjCBoxedExprClass, T, VK_RValue, OK_Ordinary), SubExpr(E),

        BoxingMethod(method), Range(R) {

    setDependence(computeDependence(this));

  }

  explicit ObjCBoxedExpr(EmptyShell Empty)

      : Expr(ObjCBoxedExprClass, Empty) {}
@@ -409,14 +411,12 @@ class ObjCEncodeExpr : public Expr { 
  SourceLocation AtLoc, RParenLoc;



public:

  ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType,

                 SourceLocation at, SourceLocation rp)

      : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary,

             EncodedType->getType()->isDependentType(),

             EncodedType->getType()->isDependentType(),

             EncodedType->getType()->isInstantiationDependentType(),

             EncodedType->getType()->containsUnexpandedParameterPack()),

        EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {}

  ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, SourceLocation at,

                 SourceLocation rp)

      : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary),

        EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {

    setDependence(computeDependence(this));

  }



  explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
@@ -456,11 +456,12 @@ class ObjCSelectorExpr : public Expr { 
  SourceLocation AtLoc, RParenLoc;



public:

  ObjCSelectorExpr(QualType T, Selector selInfo,

                   SourceLocation at, SourceLocation rp)

      : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary, false, false,

             false, false),

        SelName(selInfo), AtLoc(at), RParenLoc(rp) {}

  ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at,

                   SourceLocation rp)

      : Expr(ObjCSelectorExprClass, T, VK_RValue, OK_Ordinary),

        SelName(selInfo), AtLoc(at), RParenLoc(rp) {

    setDependence(ExprDependence::None);

  }

  explicit ObjCSelectorExpr(EmptyShell Empty)

      : Expr(ObjCSelectorExprClass, Empty) {}
@@ -508,11 +509,12 @@ public: 
  friend class ASTStmtReader;

  friend class ASTStmtWriter;



  ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol,

                 SourceLocation at, SourceLocation protoLoc, SourceLocation rp)

      : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary, false, false,

             false, false),

        TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {}

  ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at,

                   SourceLocation protoLoc, SourceLocation rp)

      : Expr(ObjCProtocolExprClass, T, VK_RValue, OK_Ordinary),

        TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {

    setDependence(ExprDependence::None);

  }

  explicit ObjCProtocolExpr(EmptyShell Empty)

      : Expr(ObjCProtocolExprClass, Empty) {}
@@ -558,17 +560,15 @@ class ObjCIvarRefExpr : public Expr { 
  bool IsFreeIvar : 1;



public:

  ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t,

                  SourceLocation l, SourceLocation oploc,

                  Expr *base,

                  bool arrow = false, bool freeIvar = false)

  ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l,

                  SourceLocation oploc, Expr *base, bool arrow = false,

                  bool freeIvar = false)

      : Expr(ObjCIvarRefExprClass, t, VK_LValue,

             d->isBitField() ? OK_BitField : OK_Ordinary,

             /*TypeDependent=*/false, base->isValueDependent(),

             base->isInstantiationDependent(),

             base->containsUnexpandedParameterPack()),

             d->isBitField() ? OK_BitField : OK_Ordinary),

        D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow),

        IsFreeIvar(freeIvar) {}

        IsFreeIvar(freeIvar) {

    setDependence(computeDependence(this));

  }



  explicit ObjCIvarRefExpr(EmptyShell Empty)

      : Expr(ObjCIvarRefExprClass, Empty) {}
@@ -645,57 +645,53 @@ private: 
  llvm::PointerUnion<Stmt *, const Type *, ObjCInterfaceDecl *> Receiver;



public:

  ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,

                      ExprValueKind VK, ExprObjectKind OK,

                      SourceLocation l, Expr *base)

      : Expr(ObjCPropertyRefExprClass, t, VK, OK,

             /*TypeDependent=*/false, base->isValueDependent(),

             base->isInstantiationDependent(),

             base->containsUnexpandedParameterPack()),

        PropertyOrGetter(PD, false), IdLoc(l), Receiver(base) {

  ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,

                      ExprObjectKind OK, SourceLocation l, Expr *base)

      : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false),

        IdLoc(l), Receiver(base) {

    assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));

    setDependence(computeDependence(this));

  }



  ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t,

                      ExprValueKind VK, ExprObjectKind OK,

                      SourceLocation l, SourceLocation sl, QualType st)

      : Expr(ObjCPropertyRefExprClass, t, VK, OK,

             /*TypeDependent=*/false, false, st->isInstantiationDependentType(),

             st->containsUnexpandedParameterPack()),

        PropertyOrGetter(PD, false), IdLoc(l), ReceiverLoc(sl),

        Receiver(st.getTypePtr()) {

  ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,

                      ExprObjectKind OK, SourceLocation l, SourceLocation sl,

                      QualType st)

      : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false),

        IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {

    assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));

    setDependence(computeDependence(this));

  }



  ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,

                      QualType T, ExprValueKind VK, ExprObjectKind OK,

                      SourceLocation IdLoc, Expr *Base)

      : Expr(ObjCPropertyRefExprClass, T, VK, OK, false,

             Base->isValueDependent(), Base->isInstantiationDependent(),

             Base->containsUnexpandedParameterPack()),

      : Expr(ObjCPropertyRefExprClass, T, VK, OK),

        PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),

        IdLoc(IdLoc), Receiver(Base) {

    assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));

    setDependence(computeDependence(this));

  }



  ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,

                      QualType T, ExprValueKind VK, ExprObjectKind OK,

                      SourceLocation IdLoc,

                      SourceLocation SuperLoc, QualType SuperTy)

      : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),

                      SourceLocation IdLoc, SourceLocation SuperLoc,

                      QualType SuperTy)

      : Expr(ObjCPropertyRefExprClass, T, VK, OK),

        PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),

        IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {

    assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));

    setDependence(computeDependence(this));

  }



  ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,

                      QualType T, ExprValueKind VK, ExprObjectKind OK,

                      SourceLocation IdLoc,

                      SourceLocation ReceiverLoc, ObjCInterfaceDecl *Receiver)

      : Expr(ObjCPropertyRefExprClass, T, VK, OK, false, false, false, false),

                      SourceLocation IdLoc, SourceLocation ReceiverLoc,

                      ObjCInterfaceDecl *Receiver)

      : Expr(ObjCPropertyRefExprClass, T, VK, OK),

        PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),

        IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {

    assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));

    setDependence(computeDependence(this));

  }



  explicit ObjCPropertyRefExpr(EmptyShell Empty)
@@ -859,20 +855,14 @@ class ObjCSubscriptRefExpr : public Expr { 
  ObjCMethodDecl *SetAtIndexMethodDecl;



public:

  ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T,

                       ExprValueKind VK, ExprObjectKind OK,

                       ObjCMethodDecl *getMethod,

  ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK,

                       ExprObjectKind OK, ObjCMethodDecl *getMethod,

                       ObjCMethodDecl *setMethod, SourceLocation RB)

      : Expr(ObjCSubscriptRefExprClass, T, VK, OK,

             base->isTypeDependent() || key->isTypeDependent(),

             base->isValueDependent() || key->isValueDependent(),

             (base->isInstantiationDependent() ||

              key->isInstantiationDependent()),

             (base->containsUnexpandedParameterPack() ||

              key->containsUnexpandedParameterPack())),

        RBracket(RB), GetAtIndexMethodDecl(getMethod),

        SetAtIndexMethodDecl(setMethod) {

    SubExprs[BASE] = base; SubExprs[KEY] = key;

      : Expr(ObjCSubscriptRefExprClass, T, VK, OK), RBracket(RB),

        GetAtIndexMethodDecl(getMethod), SetAtIndexMethodDecl(setMethod) {

    SubExprs[BASE] = base;

    SubExprs[KEY] = key;

    setDependence(computeDependence(this));

  }



  explicit ObjCSubscriptRefExpr(EmptyShell Empty)
@@ -1505,11 +1495,10 @@ class ObjCIsaExpr : public Expr { 
public:

  ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,

              QualType ty)

      : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary,

             /*TypeDependent=*/false, base->isValueDependent(),

             base->isInstantiationDependent(),

             /*ContainsUnexpandedParameterPack=*/false),

        Base(base), IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {}

      : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary), Base(base),

        IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {

    setDependence(computeDependence(this));

  }



  /// Build an empty expression.

  explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {}
@@ -1591,12 +1580,10 @@ class ObjCIndirectCopyRestoreExpr : public Expr { 


public:

  ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)

      : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary,

             operand->isTypeDependent(), operand->isValueDependent(),

             operand->isInstantiationDependent(),

             operand->containsUnexpandedParameterPack()),

      : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary),

        Operand(operand) {

    setShouldCopy(shouldCopy);

    setDependence(computeDependence(this));

  }



  Expr *getSubExpr() { return cast<Expr>(Operand); }
@@ -1705,9 +1692,10 @@ class ObjCAvailabilityCheckExpr : public Expr { 
public:

  ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc,

                            SourceLocation RParen, QualType Ty)

      : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary, false,

             false, false, false),

        VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {}

      : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_RValue, OK_Ordinary),

        VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {

    setDependence(ExprDependence::None);

  }



  explicit ObjCAvailabilityCheckExpr(EmptyShell Shell)

      : Expr(ObjCAvailabilityCheckExprClass, Shell) {}