Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- ExprObjC.h - Classes for representing ObjC expressions ---*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. //  This file defines the ExprObjC interface and subclasses.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_CLANG_AST_EXPROBJC_H
  14. #define LLVM_CLANG_AST_EXPROBJC_H
  15.  
  16. #include "clang/AST/ComputeDependence.h"
  17. #include "clang/AST/Decl.h"
  18. #include "clang/AST/DeclObjC.h"
  19. #include "clang/AST/DependenceFlags.h"
  20. #include "clang/AST/Expr.h"
  21. #include "clang/AST/OperationKinds.h"
  22. #include "clang/AST/SelectorLocationsKind.h"
  23. #include "clang/AST/Stmt.h"
  24. #include "clang/AST/Type.h"
  25. #include "clang/Basic/IdentifierTable.h"
  26. #include "clang/Basic/LLVM.h"
  27. #include "clang/Basic/SourceLocation.h"
  28. #include "clang/Basic/Specifiers.h"
  29. #include "llvm/ADT/ArrayRef.h"
  30. #include "llvm/ADT/PointerIntPair.h"
  31. #include "llvm/ADT/PointerUnion.h"
  32. #include "llvm/ADT/StringRef.h"
  33. #include "llvm/ADT/iterator_range.h"
  34. #include "llvm/Support/Casting.h"
  35. #include "llvm/Support/Compiler.h"
  36. #include "llvm/Support/TrailingObjects.h"
  37. #include "llvm/Support/VersionTuple.h"
  38. #include "llvm/Support/type_traits.h"
  39. #include <cassert>
  40. #include <cstddef>
  41. #include <cstdint>
  42. #include <optional>
  43.  
  44. namespace clang {
  45.  
  46. class ASTContext;
  47. class CXXBaseSpecifier;
  48.  
  49. /// ObjCStringLiteral, used for Objective-C string literals
  50. /// i.e. @"foo".
  51. class ObjCStringLiteral : public Expr {
  52.   Stmt *String;
  53.   SourceLocation AtLoc;
  54.  
  55. public:
  56.   ObjCStringLiteral(StringLiteral *SL, QualType T, SourceLocation L)
  57.       : Expr(ObjCStringLiteralClass, T, VK_PRValue, OK_Ordinary), String(SL),
  58.         AtLoc(L) {
  59.     setDependence(ExprDependence::None);
  60.   }
  61.   explicit ObjCStringLiteral(EmptyShell Empty)
  62.       : Expr(ObjCStringLiteralClass, Empty) {}
  63.  
  64.   StringLiteral *getString() { return cast<StringLiteral>(String); }
  65.   const StringLiteral *getString() const { return cast<StringLiteral>(String); }
  66.   void setString(StringLiteral *S) { String = S; }
  67.  
  68.   SourceLocation getAtLoc() const { return AtLoc; }
  69.   void setAtLoc(SourceLocation L) { AtLoc = L; }
  70.  
  71.   SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
  72.   SourceLocation getEndLoc() const LLVM_READONLY { return String->getEndLoc(); }
  73.  
  74.   // Iterators
  75.   child_range children() { return child_range(&String, &String+1); }
  76.  
  77.   const_child_range children() const {
  78.     return const_child_range(&String, &String + 1);
  79.   }
  80.  
  81.   static bool classof(const Stmt *T) {
  82.     return T->getStmtClass() == ObjCStringLiteralClass;
  83.   }
  84. };
  85.  
  86. /// ObjCBoolLiteralExpr - Objective-C Boolean Literal.
  87. class ObjCBoolLiteralExpr : public Expr {
  88.   bool Value;
  89.   SourceLocation Loc;
  90.  
  91. public:
  92.   ObjCBoolLiteralExpr(bool val, QualType Ty, SourceLocation l)
  93.       : Expr(ObjCBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary), Value(val),
  94.         Loc(l) {
  95.     setDependence(ExprDependence::None);
  96.   }
  97.   explicit ObjCBoolLiteralExpr(EmptyShell Empty)
  98.       : Expr(ObjCBoolLiteralExprClass, Empty) {}
  99.  
  100.   bool getValue() const { return Value; }
  101.   void setValue(bool V) { Value = V; }
  102.  
  103.   SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
  104.   SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
  105.  
  106.   SourceLocation getLocation() const { return Loc; }
  107.   void setLocation(SourceLocation L) { Loc = L; }
  108.  
  109.   // Iterators
  110.   child_range children() {
  111.     return child_range(child_iterator(), child_iterator());
  112.   }
  113.  
  114.   const_child_range children() const {
  115.     return const_child_range(const_child_iterator(), const_child_iterator());
  116.   }
  117.  
  118.   static bool classof(const Stmt *T) {
  119.     return T->getStmtClass() == ObjCBoolLiteralExprClass;
  120.   }
  121. };
  122.  
  123. /// ObjCBoxedExpr - used for generalized expression boxing.
  124. /// as in: @(strdup("hello world")), @(random()) or @(view.frame)
  125. /// Also used for boxing non-parenthesized numeric literals;
  126. /// as in: @42 or \@true (c++/objc++) or \@__objc_yes (c/objc).
  127. class ObjCBoxedExpr : public Expr {
  128.   Stmt *SubExpr;
  129.   ObjCMethodDecl *BoxingMethod;
  130.   SourceRange Range;
  131.  
  132. public:
  133.   friend class ASTStmtReader;
  134.  
  135.   ObjCBoxedExpr(Expr *E, QualType T, ObjCMethodDecl *method, SourceRange R)
  136.       : Expr(ObjCBoxedExprClass, T, VK_PRValue, OK_Ordinary), SubExpr(E),
  137.         BoxingMethod(method), Range(R) {
  138.     setDependence(computeDependence(this));
  139.   }
  140.   explicit ObjCBoxedExpr(EmptyShell Empty)
  141.       : Expr(ObjCBoxedExprClass, Empty) {}
  142.  
  143.   Expr *getSubExpr() { return cast<Expr>(SubExpr); }
  144.   const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
  145.  
  146.   ObjCMethodDecl *getBoxingMethod() const {
  147.     return BoxingMethod;
  148.   }
  149.  
  150.   // Indicates whether this boxed expression can be emitted as a compile-time
  151.   // constant.
  152.   bool isExpressibleAsConstantInitializer() const {
  153.     return !BoxingMethod && SubExpr;
  154.   }
  155.  
  156.   SourceLocation getAtLoc() const { return Range.getBegin(); }
  157.  
  158.   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
  159.   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
  160.  
  161.   SourceRange getSourceRange() const LLVM_READONLY {
  162.     return Range;
  163.   }
  164.  
  165.   // Iterators
  166.   child_range children() { return child_range(&SubExpr, &SubExpr+1); }
  167.  
  168.   const_child_range children() const {
  169.     return const_child_range(&SubExpr, &SubExpr + 1);
  170.   }
  171.  
  172.   using const_arg_iterator = ConstExprIterator;
  173.  
  174.   const_arg_iterator arg_begin() const {
  175.     return reinterpret_cast<Stmt const * const*>(&SubExpr);
  176.   }
  177.  
  178.   const_arg_iterator arg_end() const {
  179.     return reinterpret_cast<Stmt const * const*>(&SubExpr + 1);
  180.   }
  181.  
  182.   static bool classof(const Stmt *T) {
  183.     return T->getStmtClass() == ObjCBoxedExprClass;
  184.   }
  185. };
  186.  
  187. /// ObjCArrayLiteral - used for objective-c array containers; as in:
  188. /// @[@"Hello", NSApp, [NSNumber numberWithInt:42]];
  189. class ObjCArrayLiteral final
  190.     : public Expr,
  191.       private llvm::TrailingObjects<ObjCArrayLiteral, Expr *> {
  192.   unsigned NumElements;
  193.   SourceRange Range;
  194.   ObjCMethodDecl *ArrayWithObjectsMethod;
  195.  
  196.   ObjCArrayLiteral(ArrayRef<Expr *> Elements,
  197.                    QualType T, ObjCMethodDecl * Method,
  198.                    SourceRange SR);
  199.  
  200.   explicit ObjCArrayLiteral(EmptyShell Empty, unsigned NumElements)
  201.       : Expr(ObjCArrayLiteralClass, Empty), NumElements(NumElements) {}
  202.  
  203. public:
  204.   friend class ASTStmtReader;
  205.   friend TrailingObjects;
  206.  
  207.   static ObjCArrayLiteral *Create(const ASTContext &C,
  208.                                   ArrayRef<Expr *> Elements,
  209.                                   QualType T, ObjCMethodDecl * Method,
  210.                                   SourceRange SR);
  211.  
  212.   static ObjCArrayLiteral *CreateEmpty(const ASTContext &C,
  213.                                        unsigned NumElements);
  214.  
  215.   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
  216.   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
  217.   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
  218.  
  219.   /// Retrieve elements of array of literals.
  220.   Expr **getElements() { return getTrailingObjects<Expr *>(); }
  221.  
  222.   /// Retrieve elements of array of literals.
  223.   const Expr * const *getElements() const {
  224.     return getTrailingObjects<Expr *>();
  225.   }
  226.  
  227.   /// getNumElements - Return number of elements of objective-c array literal.
  228.   unsigned getNumElements() const { return NumElements; }
  229.  
  230.   /// getElement - Return the Element at the specified index.
  231.   Expr *getElement(unsigned Index) {
  232.     assert((Index < NumElements) && "Arg access out of range!");
  233.     return getElements()[Index];
  234.   }
  235.   const Expr *getElement(unsigned Index) const {
  236.     assert((Index < NumElements) && "Arg access out of range!");
  237.     return getElements()[Index];
  238.   }
  239.  
  240.   ObjCMethodDecl *getArrayWithObjectsMethod() const {
  241.     return ArrayWithObjectsMethod;
  242.   }
  243.  
  244.   // Iterators
  245.   child_range children() {
  246.     return child_range(reinterpret_cast<Stmt **>(getElements()),
  247.                        reinterpret_cast<Stmt **>(getElements()) + NumElements);
  248.   }
  249.  
  250.   const_child_range children() const {
  251.     auto Children = const_cast<ObjCArrayLiteral *>(this)->children();
  252.     return const_child_range(Children.begin(), Children.end());
  253.   }
  254.  
  255.   static bool classof(const Stmt *T) {
  256.       return T->getStmtClass() == ObjCArrayLiteralClass;
  257.   }
  258. };
  259.  
  260. /// An element in an Objective-C dictionary literal.
  261. ///
  262. struct ObjCDictionaryElement {
  263.   /// The key for the dictionary element.
  264.   Expr *Key;
  265.  
  266.   /// The value of the dictionary element.
  267.   Expr *Value;
  268.  
  269.   /// The location of the ellipsis, if this is a pack expansion.
  270.   SourceLocation EllipsisLoc;
  271.  
  272.   /// The number of elements this pack expansion will expand to, if
  273.   /// this is a pack expansion and is known.
  274.   std::optional<unsigned> NumExpansions;
  275.  
  276.   /// Determines whether this dictionary element is a pack expansion.
  277.   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
  278. };
  279.  
  280. } // namespace clang
  281.  
  282. namespace clang {
  283.  
  284. /// Internal struct for storing Key/value pair.
  285. struct ObjCDictionaryLiteral_KeyValuePair {
  286.   Expr *Key;
  287.   Expr *Value;
  288. };
  289.  
  290. /// Internal struct to describes an element that is a pack
  291. /// expansion, used if any of the elements in the dictionary literal
  292. /// are pack expansions.
  293. struct ObjCDictionaryLiteral_ExpansionData {
  294.   /// The location of the ellipsis, if this element is a pack
  295.   /// expansion.
  296.   SourceLocation EllipsisLoc;
  297.  
  298.   /// If non-zero, the number of elements that this pack
  299.   /// expansion will expand to (+1).
  300.   unsigned NumExpansionsPlusOne;
  301. };
  302.  
  303. /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary
  304. /// literals; as in:  @{@"name" : NSUserName(), @"date" : [NSDate date] };
  305. class ObjCDictionaryLiteral final
  306.     : public Expr,
  307.       private llvm::TrailingObjects<ObjCDictionaryLiteral,
  308.                                     ObjCDictionaryLiteral_KeyValuePair,
  309.                                     ObjCDictionaryLiteral_ExpansionData> {
  310.   /// The number of elements in this dictionary literal.
  311.   unsigned NumElements : 31;
  312.  
  313.   /// Determine whether this dictionary literal has any pack expansions.
  314.   ///
  315.   /// If the dictionary literal has pack expansions, then there will
  316.   /// be an array of pack expansion data following the array of
  317.   /// key/value pairs, which provide the locations of the ellipses (if
  318.   /// any) and number of elements in the expansion (if known). If
  319.   /// there are no pack expansions, we optimize away this storage.
  320.   unsigned HasPackExpansions : 1;
  321.  
  322.   SourceRange Range;
  323.   ObjCMethodDecl *DictWithObjectsMethod;
  324.  
  325.   using KeyValuePair = ObjCDictionaryLiteral_KeyValuePair;
  326.   using ExpansionData = ObjCDictionaryLiteral_ExpansionData;
  327.  
  328.   ObjCDictionaryLiteral(ArrayRef<ObjCDictionaryElement> VK,
  329.                         bool HasPackExpansions,
  330.                         QualType T, ObjCMethodDecl *method,
  331.                         SourceRange SR);
  332.  
  333.   explicit ObjCDictionaryLiteral(EmptyShell Empty, unsigned NumElements,
  334.                                  bool HasPackExpansions)
  335.       : Expr(ObjCDictionaryLiteralClass, Empty), NumElements(NumElements),
  336.         HasPackExpansions(HasPackExpansions) {}
  337.  
  338.   size_t numTrailingObjects(OverloadToken<KeyValuePair>) const {
  339.     return NumElements;
  340.   }
  341.  
  342. public:
  343.   friend class ASTStmtReader;
  344.   friend class ASTStmtWriter;
  345.   friend TrailingObjects;
  346.  
  347.   static ObjCDictionaryLiteral *Create(const ASTContext &C,
  348.                                        ArrayRef<ObjCDictionaryElement> VK,
  349.                                        bool HasPackExpansions,
  350.                                        QualType T, ObjCMethodDecl *method,
  351.                                        SourceRange SR);
  352.  
  353.   static ObjCDictionaryLiteral *CreateEmpty(const ASTContext &C,
  354.                                             unsigned NumElements,
  355.                                             bool HasPackExpansions);
  356.  
  357.   /// getNumElements - Return number of elements of objective-c dictionary
  358.   /// literal.
  359.   unsigned getNumElements() const { return NumElements; }
  360.  
  361.   ObjCDictionaryElement getKeyValueElement(unsigned Index) const {
  362.     assert((Index < NumElements) && "Arg access out of range!");
  363.     const KeyValuePair &KV = getTrailingObjects<KeyValuePair>()[Index];
  364.     ObjCDictionaryElement Result = {KV.Key, KV.Value, SourceLocation(),
  365.                                     std::nullopt};
  366.     if (HasPackExpansions) {
  367.       const ExpansionData &Expansion =
  368.           getTrailingObjects<ExpansionData>()[Index];
  369.       Result.EllipsisLoc = Expansion.EllipsisLoc;
  370.       if (Expansion.NumExpansionsPlusOne > 0)
  371.         Result.NumExpansions = Expansion.NumExpansionsPlusOne - 1;
  372.     }
  373.     return Result;
  374.   }
  375.  
  376.   ObjCMethodDecl *getDictWithObjectsMethod() const {
  377.     return DictWithObjectsMethod;
  378.   }
  379.  
  380.   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
  381.   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
  382.   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
  383.  
  384.   // Iterators
  385.   child_range children() {
  386.     // Note: we're taking advantage of the layout of the KeyValuePair struct
  387.     // here. If that struct changes, this code will need to change as well.
  388.     static_assert(sizeof(KeyValuePair) == sizeof(Stmt *) * 2,
  389.                   "KeyValuePair is expected size");
  390.     return child_range(
  391.         reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()),
  392.         reinterpret_cast<Stmt **>(getTrailingObjects<KeyValuePair>()) +
  393.             NumElements * 2);
  394.   }
  395.  
  396.   const_child_range children() const {
  397.     auto Children = const_cast<ObjCDictionaryLiteral *>(this)->children();
  398.     return const_child_range(Children.begin(), Children.end());
  399.   }
  400.  
  401.   static bool classof(const Stmt *T) {
  402.     return T->getStmtClass() == ObjCDictionaryLiteralClass;
  403.   }
  404. };
  405.  
  406. /// ObjCEncodeExpr, used for \@encode in Objective-C.  \@encode has the same
  407. /// type and behavior as StringLiteral except that the string initializer is
  408. /// obtained from ASTContext with the encoding type as an argument.
  409. class ObjCEncodeExpr : public Expr {
  410.   TypeSourceInfo *EncodedType;
  411.   SourceLocation AtLoc, RParenLoc;
  412.  
  413. public:
  414.   ObjCEncodeExpr(QualType T, TypeSourceInfo *EncodedType, SourceLocation at,
  415.                  SourceLocation rp)
  416.       : Expr(ObjCEncodeExprClass, T, VK_LValue, OK_Ordinary),
  417.         EncodedType(EncodedType), AtLoc(at), RParenLoc(rp) {
  418.     setDependence(computeDependence(this));
  419.   }
  420.  
  421.   explicit ObjCEncodeExpr(EmptyShell Empty) : Expr(ObjCEncodeExprClass, Empty){}
  422.  
  423.   SourceLocation getAtLoc() const { return AtLoc; }
  424.   void setAtLoc(SourceLocation L) { AtLoc = L; }
  425.   SourceLocation getRParenLoc() const { return RParenLoc; }
  426.   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
  427.  
  428.   QualType getEncodedType() const { return EncodedType->getType(); }
  429.  
  430.   TypeSourceInfo *getEncodedTypeSourceInfo() const { return EncodedType; }
  431.  
  432.   void setEncodedTypeSourceInfo(TypeSourceInfo *EncType) {
  433.     EncodedType = EncType;
  434.   }
  435.  
  436.   SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
  437.   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
  438.  
  439.   // Iterators
  440.   child_range children() {
  441.     return child_range(child_iterator(), child_iterator());
  442.   }
  443.  
  444.   const_child_range children() const {
  445.     return const_child_range(const_child_iterator(), const_child_iterator());
  446.   }
  447.  
  448.   static bool classof(const Stmt *T) {
  449.     return T->getStmtClass() == ObjCEncodeExprClass;
  450.   }
  451. };
  452.  
  453. /// ObjCSelectorExpr used for \@selector in Objective-C.
  454. class ObjCSelectorExpr : public Expr {
  455.   Selector SelName;
  456.   SourceLocation AtLoc, RParenLoc;
  457.  
  458. public:
  459.   ObjCSelectorExpr(QualType T, Selector selInfo, SourceLocation at,
  460.                    SourceLocation rp)
  461.       : Expr(ObjCSelectorExprClass, T, VK_PRValue, OK_Ordinary),
  462.         SelName(selInfo), AtLoc(at), RParenLoc(rp) {
  463.     setDependence(ExprDependence::None);
  464.   }
  465.   explicit ObjCSelectorExpr(EmptyShell Empty)
  466.       : Expr(ObjCSelectorExprClass, Empty) {}
  467.  
  468.   Selector getSelector() const { return SelName; }
  469.   void setSelector(Selector S) { SelName = S; }
  470.  
  471.   SourceLocation getAtLoc() const { return AtLoc; }
  472.   SourceLocation getRParenLoc() const { return RParenLoc; }
  473.   void setAtLoc(SourceLocation L) { AtLoc = L; }
  474.   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
  475.  
  476.   SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
  477.   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
  478.  
  479.   /// getNumArgs - Return the number of actual arguments to this call.
  480.   unsigned getNumArgs() const { return SelName.getNumArgs(); }
  481.  
  482.   // Iterators
  483.   child_range children() {
  484.     return child_range(child_iterator(), child_iterator());
  485.   }
  486.  
  487.   const_child_range children() const {
  488.     return const_child_range(const_child_iterator(), const_child_iterator());
  489.   }
  490.  
  491.   static bool classof(const Stmt *T) {
  492.     return T->getStmtClass() == ObjCSelectorExprClass;
  493.   }
  494. };
  495.  
  496. /// ObjCProtocolExpr used for protocol expression in Objective-C.
  497. ///
  498. /// This is used as: \@protocol(foo), as in:
  499. /// \code
  500. ///   [obj conformsToProtocol:@protocol(foo)]
  501. /// \endcode
  502. ///
  503. /// The return type is "Protocol*".
  504. class ObjCProtocolExpr : public Expr {
  505.   ObjCProtocolDecl *TheProtocol;
  506.   SourceLocation AtLoc, ProtoLoc, RParenLoc;
  507.  
  508. public:
  509.   friend class ASTStmtReader;
  510.   friend class ASTStmtWriter;
  511.  
  512.   ObjCProtocolExpr(QualType T, ObjCProtocolDecl *protocol, SourceLocation at,
  513.                    SourceLocation protoLoc, SourceLocation rp)
  514.       : Expr(ObjCProtocolExprClass, T, VK_PRValue, OK_Ordinary),
  515.         TheProtocol(protocol), AtLoc(at), ProtoLoc(protoLoc), RParenLoc(rp) {
  516.     setDependence(ExprDependence::None);
  517.   }
  518.   explicit ObjCProtocolExpr(EmptyShell Empty)
  519.       : Expr(ObjCProtocolExprClass, Empty) {}
  520.  
  521.   ObjCProtocolDecl *getProtocol() const { return TheProtocol; }
  522.   void setProtocol(ObjCProtocolDecl *P) { TheProtocol = P; }
  523.  
  524.   SourceLocation getProtocolIdLoc() const { return ProtoLoc; }
  525.   SourceLocation getAtLoc() const { return AtLoc; }
  526.   SourceLocation getRParenLoc() const { return RParenLoc; }
  527.   void setAtLoc(SourceLocation L) { AtLoc = L; }
  528.   void setRParenLoc(SourceLocation L) { RParenLoc = L; }
  529.  
  530.   SourceLocation getBeginLoc() const LLVM_READONLY { return AtLoc; }
  531.   SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
  532.  
  533.   // Iterators
  534.   child_range children() {
  535.     return child_range(child_iterator(), child_iterator());
  536.   }
  537.  
  538.   const_child_range children() const {
  539.     return const_child_range(const_child_iterator(), const_child_iterator());
  540.   }
  541.  
  542.   static bool classof(const Stmt *T) {
  543.     return T->getStmtClass() == ObjCProtocolExprClass;
  544.   }
  545. };
  546.  
  547. /// ObjCIvarRefExpr - A reference to an ObjC instance variable.
  548. class ObjCIvarRefExpr : public Expr {
  549.   ObjCIvarDecl *D;
  550.   Stmt *Base;
  551.   SourceLocation Loc;
  552.  
  553.   /// OpLoc - This is the location of '.' or '->'
  554.   SourceLocation OpLoc;
  555.  
  556.   // True if this is "X->F", false if this is "X.F".
  557.   bool IsArrow : 1;
  558.  
  559.   // True if ivar reference has no base (self assumed).
  560.   bool IsFreeIvar : 1;
  561.  
  562. public:
  563.   ObjCIvarRefExpr(ObjCIvarDecl *d, QualType t, SourceLocation l,
  564.                   SourceLocation oploc, Expr *base, bool arrow = false,
  565.                   bool freeIvar = false)
  566.       : Expr(ObjCIvarRefExprClass, t, VK_LValue,
  567.              d->isBitField() ? OK_BitField : OK_Ordinary),
  568.         D(d), Base(base), Loc(l), OpLoc(oploc), IsArrow(arrow),
  569.         IsFreeIvar(freeIvar) {
  570.     setDependence(computeDependence(this));
  571.   }
  572.  
  573.   explicit ObjCIvarRefExpr(EmptyShell Empty)
  574.       : Expr(ObjCIvarRefExprClass, Empty) {}
  575.  
  576.   ObjCIvarDecl *getDecl() { return D; }
  577.   const ObjCIvarDecl *getDecl() const { return D; }
  578.   void setDecl(ObjCIvarDecl *d) { D = d; }
  579.  
  580.   const Expr *getBase() const { return cast<Expr>(Base); }
  581.   Expr *getBase() { return cast<Expr>(Base); }
  582.   void setBase(Expr * base) { Base = base; }
  583.  
  584.   bool isArrow() const { return IsArrow; }
  585.   bool isFreeIvar() const { return IsFreeIvar; }
  586.   void setIsArrow(bool A) { IsArrow = A; }
  587.   void setIsFreeIvar(bool A) { IsFreeIvar = A; }
  588.  
  589.   SourceLocation getLocation() const { return Loc; }
  590.   void setLocation(SourceLocation L) { Loc = L; }
  591.  
  592.   SourceLocation getBeginLoc() const LLVM_READONLY {
  593.     return isFreeIvar() ? Loc : getBase()->getBeginLoc();
  594.   }
  595.   SourceLocation getEndLoc() const LLVM_READONLY { return Loc; }
  596.  
  597.   SourceLocation getOpLoc() const { return OpLoc; }
  598.   void setOpLoc(SourceLocation L) { OpLoc = L; }
  599.  
  600.   // Iterators
  601.   child_range children() { return child_range(&Base, &Base+1); }
  602.  
  603.   const_child_range children() const {
  604.     return const_child_range(&Base, &Base + 1);
  605.   }
  606.  
  607.   static bool classof(const Stmt *T) {
  608.     return T->getStmtClass() == ObjCIvarRefExprClass;
  609.   }
  610. };
  611.  
  612. /// ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC
  613. /// property.
  614. class ObjCPropertyRefExpr : public Expr {
  615. private:
  616.   /// If the bool is true, this is an implicit property reference; the
  617.   /// pointer is an (optional) ObjCMethodDecl and Setter may be set.
  618.   /// if the bool is false, this is an explicit property reference;
  619.   /// the pointer is an ObjCPropertyDecl and Setter is always null.
  620.   llvm::PointerIntPair<NamedDecl *, 1, bool> PropertyOrGetter;
  621.  
  622.   /// Indicates whether the property reference will result in a message
  623.   /// to the getter, the setter, or both.
  624.   /// This applies to both implicit and explicit property references.
  625.   enum MethodRefFlags {
  626.     MethodRef_None = 0,
  627.     MethodRef_Getter = 0x1,
  628.     MethodRef_Setter = 0x2
  629.   };
  630.  
  631.   /// Contains the Setter method pointer and MethodRefFlags bit flags.
  632.   llvm::PointerIntPair<ObjCMethodDecl *, 2, unsigned> SetterAndMethodRefFlags;
  633.  
  634.   // FIXME: Maybe we should store the property identifier here,
  635.   // because it's not rederivable from the other data when there's an
  636.   // implicit property with no getter (because the 'foo' -> 'setFoo:'
  637.   // transformation is lossy on the first character).
  638.  
  639.   SourceLocation IdLoc;
  640.  
  641.   /// When the receiver in property access is 'super', this is
  642.   /// the location of the 'super' keyword.  When it's an interface,
  643.   /// this is that interface.
  644.   SourceLocation ReceiverLoc;
  645.   llvm::PointerUnion<Stmt *, const Type *, ObjCInterfaceDecl *> Receiver;
  646.  
  647. public:
  648.   ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,
  649.                       ExprObjectKind OK, SourceLocation l, Expr *base)
  650.       : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false),
  651.         IdLoc(l), Receiver(base) {
  652.     assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
  653.     setDependence(computeDependence(this));
  654.   }
  655.  
  656.   ObjCPropertyRefExpr(ObjCPropertyDecl *PD, QualType t, ExprValueKind VK,
  657.                       ExprObjectKind OK, SourceLocation l, SourceLocation sl,
  658.                       QualType st)
  659.       : Expr(ObjCPropertyRefExprClass, t, VK, OK), PropertyOrGetter(PD, false),
  660.         IdLoc(l), ReceiverLoc(sl), Receiver(st.getTypePtr()) {
  661.     assert(t->isSpecificPlaceholderType(BuiltinType::PseudoObject));
  662.     setDependence(computeDependence(this));
  663.   }
  664.  
  665.   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
  666.                       QualType T, ExprValueKind VK, ExprObjectKind OK,
  667.                       SourceLocation IdLoc, Expr *Base)
  668.       : Expr(ObjCPropertyRefExprClass, T, VK, OK),
  669.         PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
  670.         IdLoc(IdLoc), Receiver(Base) {
  671.     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
  672.     setDependence(computeDependence(this));
  673.   }
  674.  
  675.   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
  676.                       QualType T, ExprValueKind VK, ExprObjectKind OK,
  677.                       SourceLocation IdLoc, SourceLocation SuperLoc,
  678.                       QualType SuperTy)
  679.       : Expr(ObjCPropertyRefExprClass, T, VK, OK),
  680.         PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
  681.         IdLoc(IdLoc), ReceiverLoc(SuperLoc), Receiver(SuperTy.getTypePtr()) {
  682.     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
  683.     setDependence(computeDependence(this));
  684.   }
  685.  
  686.   ObjCPropertyRefExpr(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
  687.                       QualType T, ExprValueKind VK, ExprObjectKind OK,
  688.                       SourceLocation IdLoc, SourceLocation ReceiverLoc,
  689.                       ObjCInterfaceDecl *Receiver)
  690.       : Expr(ObjCPropertyRefExprClass, T, VK, OK),
  691.         PropertyOrGetter(Getter, true), SetterAndMethodRefFlags(Setter, 0),
  692.         IdLoc(IdLoc), ReceiverLoc(ReceiverLoc), Receiver(Receiver) {
  693.     assert(T->isSpecificPlaceholderType(BuiltinType::PseudoObject));
  694.     setDependence(computeDependence(this));
  695.   }
  696.  
  697.   explicit ObjCPropertyRefExpr(EmptyShell Empty)
  698.       : Expr(ObjCPropertyRefExprClass, Empty) {}
  699.  
  700.   bool isImplicitProperty() const { return PropertyOrGetter.getInt(); }
  701.   bool isExplicitProperty() const { return !PropertyOrGetter.getInt(); }
  702.  
  703.   ObjCPropertyDecl *getExplicitProperty() const {
  704.     assert(!isImplicitProperty());
  705.     return cast<ObjCPropertyDecl>(PropertyOrGetter.getPointer());
  706.   }
  707.  
  708.   ObjCMethodDecl *getImplicitPropertyGetter() const {
  709.     assert(isImplicitProperty());
  710.     return cast_or_null<ObjCMethodDecl>(PropertyOrGetter.getPointer());
  711.   }
  712.  
  713.   ObjCMethodDecl *getImplicitPropertySetter() const {
  714.     assert(isImplicitProperty());
  715.     return SetterAndMethodRefFlags.getPointer();
  716.   }
  717.  
  718.   Selector getGetterSelector() const {
  719.     if (isImplicitProperty())
  720.       return getImplicitPropertyGetter()->getSelector();
  721.     return getExplicitProperty()->getGetterName();
  722.   }
  723.  
  724.   Selector getSetterSelector() const {
  725.     if (isImplicitProperty())
  726.       return getImplicitPropertySetter()->getSelector();
  727.     return getExplicitProperty()->getSetterName();
  728.   }
  729.  
  730.   /// True if the property reference will result in a message to the
  731.   /// getter.
  732.   /// This applies to both implicit and explicit property references.
  733.   bool isMessagingGetter() const {
  734.     return SetterAndMethodRefFlags.getInt() & MethodRef_Getter;
  735.   }
  736.  
  737.   /// True if the property reference will result in a message to the
  738.   /// setter.
  739.   /// This applies to both implicit and explicit property references.
  740.   bool isMessagingSetter() const {
  741.     return SetterAndMethodRefFlags.getInt() & MethodRef_Setter;
  742.   }
  743.  
  744.   void setIsMessagingGetter(bool val = true) {
  745.     setMethodRefFlag(MethodRef_Getter, val);
  746.   }
  747.  
  748.   void setIsMessagingSetter(bool val = true) {
  749.     setMethodRefFlag(MethodRef_Setter, val);
  750.   }
  751.  
  752.   const Expr *getBase() const {
  753.     return cast<Expr>(Receiver.get<Stmt*>());
  754.   }
  755.   Expr *getBase() {
  756.     return cast<Expr>(Receiver.get<Stmt*>());
  757.   }
  758.  
  759.   SourceLocation getLocation() const { return IdLoc; }
  760.  
  761.   SourceLocation getReceiverLocation() const { return ReceiverLoc; }
  762.  
  763.   QualType getSuperReceiverType() const {
  764.     return QualType(Receiver.get<const Type*>(), 0);
  765.   }
  766.  
  767.   ObjCInterfaceDecl *getClassReceiver() const {
  768.     return Receiver.get<ObjCInterfaceDecl*>();
  769.   }
  770.  
  771.   bool isObjectReceiver() const { return Receiver.is<Stmt*>(); }
  772.   bool isSuperReceiver() const { return Receiver.is<const Type*>(); }
  773.   bool isClassReceiver() const { return Receiver.is<ObjCInterfaceDecl*>(); }
  774.  
  775.   /// Determine the type of the base, regardless of the kind of receiver.
  776.   QualType getReceiverType(const ASTContext &ctx) const;
  777.  
  778.   SourceLocation getBeginLoc() const LLVM_READONLY {
  779.     return isObjectReceiver() ? getBase()->getBeginLoc()
  780.                               : getReceiverLocation();
  781.   }
  782.  
  783.   SourceLocation getEndLoc() const LLVM_READONLY { return IdLoc; }
  784.  
  785.   // Iterators
  786.   child_range children() {
  787.     if (Receiver.is<Stmt*>()) {
  788.       Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!
  789.       return child_range(begin, begin+1);
  790.     }
  791.     return child_range(child_iterator(), child_iterator());
  792.   }
  793.  
  794.   const_child_range children() const {
  795.     auto Children = const_cast<ObjCPropertyRefExpr *>(this)->children();
  796.     return const_child_range(Children.begin(), Children.end());
  797.   }
  798.  
  799.   static bool classof(const Stmt *T) {
  800.     return T->getStmtClass() == ObjCPropertyRefExprClass;
  801.   }
  802.  
  803. private:
  804.   friend class ASTStmtReader;
  805.   friend class ASTStmtWriter;
  806.  
  807.   void setExplicitProperty(ObjCPropertyDecl *D, unsigned methRefFlags) {
  808.     PropertyOrGetter.setPointer(D);
  809.     PropertyOrGetter.setInt(false);
  810.     SetterAndMethodRefFlags.setPointer(nullptr);
  811.     SetterAndMethodRefFlags.setInt(methRefFlags);
  812.   }
  813.  
  814.   void setImplicitProperty(ObjCMethodDecl *Getter, ObjCMethodDecl *Setter,
  815.                            unsigned methRefFlags) {
  816.     PropertyOrGetter.setPointer(Getter);
  817.     PropertyOrGetter.setInt(true);
  818.     SetterAndMethodRefFlags.setPointer(Setter);
  819.     SetterAndMethodRefFlags.setInt(methRefFlags);
  820.   }
  821.  
  822.   void setBase(Expr *Base) { Receiver = Base; }
  823.   void setSuperReceiver(QualType T) { Receiver = T.getTypePtr(); }
  824.   void setClassReceiver(ObjCInterfaceDecl *D) { Receiver = D; }
  825.  
  826.   void setLocation(SourceLocation L) { IdLoc = L; }
  827.   void setReceiverLocation(SourceLocation Loc) { ReceiverLoc = Loc; }
  828.  
  829.   void setMethodRefFlag(MethodRefFlags flag, bool val) {
  830.     unsigned f = SetterAndMethodRefFlags.getInt();
  831.     if (val)
  832.       f |= flag;
  833.     else
  834.       f &= ~flag;
  835.     SetterAndMethodRefFlags.setInt(f);
  836.   }
  837. };
  838.  
  839. /// ObjCSubscriptRefExpr - used for array and dictionary subscripting.
  840. /// array[4] = array[3]; dictionary[key] = dictionary[alt_key];
  841. class ObjCSubscriptRefExpr : public Expr {
  842.   // Location of ']' in an indexing expression.
  843.   SourceLocation RBracket;
  844.  
  845.   // array/dictionary base expression.
  846.   // for arrays, this is a numeric expression. For dictionaries, this is
  847.   // an objective-c object pointer expression.
  848.   enum { BASE, KEY, END_EXPR };
  849.   Stmt* SubExprs[END_EXPR];
  850.  
  851.   ObjCMethodDecl *GetAtIndexMethodDecl;
  852.  
  853.   // For immutable objects this is null. When ObjCSubscriptRefExpr is to read
  854.   // an indexed object this is null too.
  855.   ObjCMethodDecl *SetAtIndexMethodDecl;
  856.  
  857. public:
  858.   ObjCSubscriptRefExpr(Expr *base, Expr *key, QualType T, ExprValueKind VK,
  859.                        ExprObjectKind OK, ObjCMethodDecl *getMethod,
  860.                        ObjCMethodDecl *setMethod, SourceLocation RB)
  861.       : Expr(ObjCSubscriptRefExprClass, T, VK, OK), RBracket(RB),
  862.         GetAtIndexMethodDecl(getMethod), SetAtIndexMethodDecl(setMethod) {
  863.     SubExprs[BASE] = base;
  864.     SubExprs[KEY] = key;
  865.     setDependence(computeDependence(this));
  866.   }
  867.  
  868.   explicit ObjCSubscriptRefExpr(EmptyShell Empty)
  869.       : Expr(ObjCSubscriptRefExprClass, Empty) {}
  870.  
  871.   SourceLocation getRBracket() const { return RBracket; }
  872.   void setRBracket(SourceLocation RB) { RBracket = RB; }
  873.  
  874.   SourceLocation getBeginLoc() const LLVM_READONLY {
  875.     return SubExprs[BASE]->getBeginLoc();
  876.   }
  877.  
  878.   SourceLocation getEndLoc() const LLVM_READONLY { return RBracket; }
  879.  
  880.   Expr *getBaseExpr() const { return cast<Expr>(SubExprs[BASE]); }
  881.   void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
  882.  
  883.   Expr *getKeyExpr() const { return cast<Expr>(SubExprs[KEY]); }
  884.   void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
  885.  
  886.   ObjCMethodDecl *getAtIndexMethodDecl() const {
  887.     return GetAtIndexMethodDecl;
  888.   }
  889.  
  890.   ObjCMethodDecl *setAtIndexMethodDecl() const {
  891.     return SetAtIndexMethodDecl;
  892.   }
  893.  
  894.   bool isArraySubscriptRefExpr() const {
  895.     return getKeyExpr()->getType()->isIntegralOrEnumerationType();
  896.   }
  897.  
  898.   child_range children() {
  899.     return child_range(SubExprs, SubExprs+END_EXPR);
  900.   }
  901.  
  902.   const_child_range children() const {
  903.     return const_child_range(SubExprs, SubExprs + END_EXPR);
  904.   }
  905.  
  906.   static bool classof(const Stmt *T) {
  907.     return T->getStmtClass() == ObjCSubscriptRefExprClass;
  908.   }
  909.  
  910. private:
  911.   friend class ASTStmtReader;
  912. };
  913.  
  914. /// An expression that sends a message to the given Objective-C
  915. /// object or class.
  916. ///
  917. /// The following contains two message send expressions:
  918. ///
  919. /// \code
  920. ///   [[NSString alloc] initWithString:@"Hello"]
  921. /// \endcode
  922. ///
  923. /// The innermost message send invokes the "alloc" class method on the
  924. /// NSString class, while the outermost message send invokes the
  925. /// "initWithString" instance method on the object returned from
  926. /// NSString's "alloc". In all, an Objective-C message send can take
  927. /// on four different (although related) forms:
  928. ///
  929. ///   1. Send to an object instance.
  930. ///   2. Send to a class.
  931. ///   3. Send to the superclass instance of the current class.
  932. ///   4. Send to the superclass of the current class.
  933. ///
  934. /// All four kinds of message sends are modeled by the ObjCMessageExpr
  935. /// class, and can be distinguished via \c getReceiverKind(). Example:
  936. ///
  937. /// The "void *" trailing objects are actually ONE void * (the
  938. /// receiver pointer), and NumArgs Expr *. But due to the
  939. /// implementation of children(), these must be together contiguously.
  940. class ObjCMessageExpr final
  941.     : public Expr,
  942.       private llvm::TrailingObjects<ObjCMessageExpr, void *, SourceLocation> {
  943.   /// Stores either the selector that this message is sending
  944.   /// to (when \c HasMethod is zero) or an \c ObjCMethodDecl pointer
  945.   /// referring to the method that we type-checked against.
  946.   uintptr_t SelectorOrMethod = 0;
  947.  
  948.   enum { NumArgsBitWidth = 16 };
  949.  
  950.   /// The number of arguments in the message send, not
  951.   /// including the receiver.
  952.   unsigned NumArgs : NumArgsBitWidth;
  953.  
  954.   /// The kind of message send this is, which is one of the
  955.   /// ReceiverKind values.
  956.   ///
  957.   /// We pad this out to a byte to avoid excessive masking and shifting.
  958.   unsigned Kind : 8;
  959.  
  960.   /// Whether we have an actual method prototype in \c
  961.   /// SelectorOrMethod.
  962.   ///
  963.   /// When non-zero, we have a method declaration; otherwise, we just
  964.   /// have a selector.
  965.   unsigned HasMethod : 1;
  966.  
  967.   /// Whether this message send is a "delegate init call",
  968.   /// i.e. a call of an init method on self from within an init method.
  969.   unsigned IsDelegateInitCall : 1;
  970.  
  971.   /// Whether this message send was implicitly generated by
  972.   /// the implementation rather than explicitly written by the user.
  973.   unsigned IsImplicit : 1;
  974.  
  975.   /// Whether the locations of the selector identifiers are in a
  976.   /// "standard" position, a enum SelectorLocationsKind.
  977.   unsigned SelLocsKind : 2;
  978.  
  979.   /// When the message expression is a send to 'super', this is
  980.   /// the location of the 'super' keyword.
  981.   SourceLocation SuperLoc;
  982.  
  983.   /// The source locations of the open and close square
  984.   /// brackets ('[' and ']', respectively).
  985.   SourceLocation LBracLoc, RBracLoc;
  986.  
  987.   ObjCMessageExpr(EmptyShell Empty, unsigned NumArgs)
  988.       : Expr(ObjCMessageExprClass, Empty), Kind(0), HasMethod(false),
  989.         IsDelegateInitCall(false), IsImplicit(false), SelLocsKind(0) {
  990.     setNumArgs(NumArgs);
  991.   }
  992.  
  993.   ObjCMessageExpr(QualType T, ExprValueKind VK,
  994.                   SourceLocation LBracLoc,
  995.                   SourceLocation SuperLoc,
  996.                   bool IsInstanceSuper,
  997.                   QualType SuperType,
  998.                   Selector Sel,
  999.                   ArrayRef<SourceLocation> SelLocs,
  1000.                   SelectorLocationsKind SelLocsK,
  1001.                   ObjCMethodDecl *Method,
  1002.                   ArrayRef<Expr *> Args,
  1003.                   SourceLocation RBracLoc,
  1004.                   bool isImplicit);
  1005.   ObjCMessageExpr(QualType T, ExprValueKind VK,
  1006.                   SourceLocation LBracLoc,
  1007.                   TypeSourceInfo *Receiver,
  1008.                   Selector Sel,
  1009.                   ArrayRef<SourceLocation> SelLocs,
  1010.                   SelectorLocationsKind SelLocsK,
  1011.                   ObjCMethodDecl *Method,
  1012.                   ArrayRef<Expr *> Args,
  1013.                   SourceLocation RBracLoc,
  1014.                   bool isImplicit);
  1015.   ObjCMessageExpr(QualType T, ExprValueKind VK,
  1016.                   SourceLocation LBracLoc,
  1017.                   Expr *Receiver,
  1018.                   Selector Sel,
  1019.                   ArrayRef<SourceLocation> SelLocs,
  1020.                   SelectorLocationsKind SelLocsK,
  1021.                   ObjCMethodDecl *Method,
  1022.                   ArrayRef<Expr *> Args,
  1023.                   SourceLocation RBracLoc,
  1024.                   bool isImplicit);
  1025.  
  1026.   size_t numTrailingObjects(OverloadToken<void *>) const { return NumArgs + 1; }
  1027.  
  1028.   void setNumArgs(unsigned Num) {
  1029.     assert((Num >> NumArgsBitWidth) == 0 && "Num of args is out of range!");
  1030.     NumArgs = Num;
  1031.   }
  1032.  
  1033.   void initArgsAndSelLocs(ArrayRef<Expr *> Args,
  1034.                           ArrayRef<SourceLocation> SelLocs,
  1035.                           SelectorLocationsKind SelLocsK);
  1036.  
  1037.   /// Retrieve the pointer value of the message receiver.
  1038.   void *getReceiverPointer() const { return *getTrailingObjects<void *>(); }
  1039.  
  1040.   /// Set the pointer value of the message receiver.
  1041.   void setReceiverPointer(void *Value) {
  1042.     *getTrailingObjects<void *>() = Value;
  1043.   }
  1044.  
  1045.   SelectorLocationsKind getSelLocsKind() const {
  1046.     return (SelectorLocationsKind)SelLocsKind;
  1047.   }
  1048.  
  1049.   bool hasStandardSelLocs() const {
  1050.     return getSelLocsKind() != SelLoc_NonStandard;
  1051.   }
  1052.  
  1053.   /// Get a pointer to the stored selector identifiers locations array.
  1054.   /// No locations will be stored if HasStandardSelLocs is true.
  1055.   SourceLocation *getStoredSelLocs() {
  1056.     return getTrailingObjects<SourceLocation>();
  1057.   }
  1058.   const SourceLocation *getStoredSelLocs() const {
  1059.     return getTrailingObjects<SourceLocation>();
  1060.   }
  1061.  
  1062.   /// Get the number of stored selector identifiers locations.
  1063.   /// No locations will be stored if HasStandardSelLocs is true.
  1064.   unsigned getNumStoredSelLocs() const {
  1065.     if (hasStandardSelLocs())
  1066.       return 0;
  1067.     return getNumSelectorLocs();
  1068.   }
  1069.  
  1070.   static ObjCMessageExpr *alloc(const ASTContext &C,
  1071.                                 ArrayRef<Expr *> Args,
  1072.                                 SourceLocation RBraceLoc,
  1073.                                 ArrayRef<SourceLocation> SelLocs,
  1074.                                 Selector Sel,
  1075.                                 SelectorLocationsKind &SelLocsK);
  1076.   static ObjCMessageExpr *alloc(const ASTContext &C,
  1077.                                 unsigned NumArgs,
  1078.                                 unsigned NumStoredSelLocs);
  1079.  
  1080. public:
  1081.   friend class ASTStmtReader;
  1082.   friend class ASTStmtWriter;
  1083.   friend TrailingObjects;
  1084.  
  1085.   /// The kind of receiver this message is sending to.
  1086.   enum ReceiverKind {
  1087.     /// The receiver is a class.
  1088.     Class = 0,
  1089.  
  1090.     /// The receiver is an object instance.
  1091.     Instance,
  1092.  
  1093.     /// The receiver is a superclass.
  1094.     SuperClass,
  1095.  
  1096.     /// The receiver is the instance of the superclass object.
  1097.     SuperInstance
  1098.   };
  1099.  
  1100.   /// Create a message send to super.
  1101.   ///
  1102.   /// \param Context The ASTContext in which this expression will be created.
  1103.   ///
  1104.   /// \param T The result type of this message.
  1105.   ///
  1106.   /// \param VK The value kind of this message.  A message returning
  1107.   /// a l-value or r-value reference will be an l-value or x-value,
  1108.   /// respectively.
  1109.   ///
  1110.   /// \param LBracLoc The location of the open square bracket '['.
  1111.   ///
  1112.   /// \param SuperLoc The location of the "super" keyword.
  1113.   ///
  1114.   /// \param IsInstanceSuper Whether this is an instance "super"
  1115.   /// message (otherwise, it's a class "super" message).
  1116.   ///
  1117.   /// \param Sel The selector used to determine which method gets called.
  1118.   ///
  1119.   /// \param Method The Objective-C method against which this message
  1120.   /// send was type-checked. May be nullptr.
  1121.   ///
  1122.   /// \param Args The message send arguments.
  1123.   ///
  1124.   /// \param RBracLoc The location of the closing square bracket ']'.
  1125.   static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
  1126.                                  ExprValueKind VK,
  1127.                                  SourceLocation LBracLoc,
  1128.                                  SourceLocation SuperLoc,
  1129.                                  bool IsInstanceSuper,
  1130.                                  QualType SuperType,
  1131.                                  Selector Sel,
  1132.                                  ArrayRef<SourceLocation> SelLocs,
  1133.                                  ObjCMethodDecl *Method,
  1134.                                  ArrayRef<Expr *> Args,
  1135.                                  SourceLocation RBracLoc,
  1136.                                  bool isImplicit);
  1137.  
  1138.   /// Create a class message send.
  1139.   ///
  1140.   /// \param Context The ASTContext in which this expression will be created.
  1141.   ///
  1142.   /// \param T The result type of this message.
  1143.   ///
  1144.   /// \param VK The value kind of this message.  A message returning
  1145.   /// a l-value or r-value reference will be an l-value or x-value,
  1146.   /// respectively.
  1147.   ///
  1148.   /// \param LBracLoc The location of the open square bracket '['.
  1149.   ///
  1150.   /// \param Receiver The type of the receiver, including
  1151.   /// source-location information.
  1152.   ///
  1153.   /// \param Sel The selector used to determine which method gets called.
  1154.   ///
  1155.   /// \param Method The Objective-C method against which this message
  1156.   /// send was type-checked. May be nullptr.
  1157.   ///
  1158.   /// \param Args The message send arguments.
  1159.   ///
  1160.   /// \param RBracLoc The location of the closing square bracket ']'.
  1161.   static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
  1162.                                  ExprValueKind VK,
  1163.                                  SourceLocation LBracLoc,
  1164.                                  TypeSourceInfo *Receiver,
  1165.                                  Selector Sel,
  1166.                                  ArrayRef<SourceLocation> SelLocs,
  1167.                                  ObjCMethodDecl *Method,
  1168.                                  ArrayRef<Expr *> Args,
  1169.                                  SourceLocation RBracLoc,
  1170.                                  bool isImplicit);
  1171.  
  1172.   /// Create an instance message send.
  1173.   ///
  1174.   /// \param Context The ASTContext in which this expression will be created.
  1175.   ///
  1176.   /// \param T The result type of this message.
  1177.   ///
  1178.   /// \param VK The value kind of this message.  A message returning
  1179.   /// a l-value or r-value reference will be an l-value or x-value,
  1180.   /// respectively.
  1181.   ///
  1182.   /// \param LBracLoc The location of the open square bracket '['.
  1183.   ///
  1184.   /// \param Receiver The expression used to produce the object that
  1185.   /// will receive this message.
  1186.   ///
  1187.   /// \param Sel The selector used to determine which method gets called.
  1188.   ///
  1189.   /// \param Method The Objective-C method against which this message
  1190.   /// send was type-checked. May be nullptr.
  1191.   ///
  1192.   /// \param Args The message send arguments.
  1193.   ///
  1194.   /// \param RBracLoc The location of the closing square bracket ']'.
  1195.   static ObjCMessageExpr *Create(const ASTContext &Context, QualType T,
  1196.                                  ExprValueKind VK,
  1197.                                  SourceLocation LBracLoc,
  1198.                                  Expr *Receiver,
  1199.                                  Selector Sel,
  1200.                                  ArrayRef<SourceLocation> SeLocs,
  1201.                                  ObjCMethodDecl *Method,
  1202.                                  ArrayRef<Expr *> Args,
  1203.                                  SourceLocation RBracLoc,
  1204.                                  bool isImplicit);
  1205.  
  1206.   /// Create an empty Objective-C message expression, to be
  1207.   /// filled in by subsequent calls.
  1208.   ///
  1209.   /// \param Context The context in which the message send will be created.
  1210.   ///
  1211.   /// \param NumArgs The number of message arguments, not including
  1212.   /// the receiver.
  1213.   static ObjCMessageExpr *CreateEmpty(const ASTContext &Context,
  1214.                                       unsigned NumArgs,
  1215.                                       unsigned NumStoredSelLocs);
  1216.  
  1217.   /// Indicates whether the message send was implicitly
  1218.   /// generated by the implementation. If false, it was written explicitly
  1219.   /// in the source code.
  1220.   bool isImplicit() const { return IsImplicit; }
  1221.  
  1222.   /// Determine the kind of receiver that this message is being
  1223.   /// sent to.
  1224.   ReceiverKind getReceiverKind() const { return (ReceiverKind)Kind; }
  1225.  
  1226.   /// \return the return type of the message being sent.
  1227.   /// This is not always the type of the message expression itself because
  1228.   /// of references (the expression would not have a reference type).
  1229.   /// It is also not always the declared return type of the method because
  1230.   /// of `instancetype` (in that case it's an expression type).
  1231.   QualType getCallReturnType(ASTContext &Ctx) const;
  1232.  
  1233.   /// Source range of the receiver.
  1234.   SourceRange getReceiverRange() const;
  1235.  
  1236.   /// Determine whether this is an instance message to either a
  1237.   /// computed object or to super.
  1238.   bool isInstanceMessage() const {
  1239.     return getReceiverKind() == Instance || getReceiverKind() == SuperInstance;
  1240.   }
  1241.  
  1242.   /// Determine whether this is an class message to either a
  1243.   /// specified class or to super.
  1244.   bool isClassMessage() const {
  1245.     return getReceiverKind() == Class || getReceiverKind() == SuperClass;
  1246.   }
  1247.  
  1248.   /// Returns the object expression (receiver) for an instance message,
  1249.   /// or null for a message that is not an instance message.
  1250.   Expr *getInstanceReceiver() {
  1251.     if (getReceiverKind() == Instance)
  1252.       return static_cast<Expr *>(getReceiverPointer());
  1253.  
  1254.     return nullptr;
  1255.   }
  1256.   const Expr *getInstanceReceiver() const {
  1257.     return const_cast<ObjCMessageExpr*>(this)->getInstanceReceiver();
  1258.   }
  1259.  
  1260.   /// Turn this message send into an instance message that
  1261.   /// computes the receiver object with the given expression.
  1262.   void setInstanceReceiver(Expr *rec) {
  1263.     Kind = Instance;
  1264.     setReceiverPointer(rec);
  1265.   }
  1266.  
  1267.   /// Returns the type of a class message send, or NULL if the
  1268.   /// message is not a class message.
  1269.   QualType getClassReceiver() const {
  1270.     if (TypeSourceInfo *TSInfo = getClassReceiverTypeInfo())
  1271.       return TSInfo->getType();
  1272.  
  1273.     return {};
  1274.   }
  1275.  
  1276.   /// Returns a type-source information of a class message
  1277.   /// send, or nullptr if the message is not a class message.
  1278.   TypeSourceInfo *getClassReceiverTypeInfo() const {
  1279.     if (getReceiverKind() == Class)
  1280.       return reinterpret_cast<TypeSourceInfo *>(getReceiverPointer());
  1281.     return nullptr;
  1282.   }
  1283.  
  1284.   void setClassReceiver(TypeSourceInfo *TSInfo) {
  1285.     Kind = Class;
  1286.     setReceiverPointer(TSInfo);
  1287.   }
  1288.  
  1289.   /// Retrieve the location of the 'super' keyword for a class
  1290.   /// or instance message to 'super', otherwise an invalid source location.
  1291.   SourceLocation getSuperLoc() const {
  1292.     if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
  1293.       return SuperLoc;
  1294.  
  1295.     return SourceLocation();
  1296.   }
  1297.  
  1298.   /// Retrieve the receiver type to which this message is being directed.
  1299.   ///
  1300.   /// This routine cross-cuts all of the different kinds of message
  1301.   /// sends to determine what the underlying (statically known) type
  1302.   /// of the receiver will be; use \c getReceiverKind() to determine
  1303.   /// whether the message is a class or an instance method, whether it
  1304.   /// is a send to super or not, etc.
  1305.   ///
  1306.   /// \returns The type of the receiver.
  1307.   QualType getReceiverType() const;
  1308.  
  1309.   /// Retrieve the Objective-C interface to which this message
  1310.   /// is being directed, if known.
  1311.   ///
  1312.   /// This routine cross-cuts all of the different kinds of message
  1313.   /// sends to determine what the underlying (statically known) type
  1314.   /// of the receiver will be; use \c getReceiverKind() to determine
  1315.   /// whether the message is a class or an instance method, whether it
  1316.   /// is a send to super or not, etc.
  1317.   ///
  1318.   /// \returns The Objective-C interface if known, otherwise nullptr.
  1319.   ObjCInterfaceDecl *getReceiverInterface() const;
  1320.  
  1321.   /// Retrieve the type referred to by 'super'.
  1322.   ///
  1323.   /// The returned type will either be an ObjCInterfaceType (for an
  1324.   /// class message to super) or an ObjCObjectPointerType that refers
  1325.   /// to a class (for an instance message to super);
  1326.   QualType getSuperType() const {
  1327.     if (getReceiverKind() == SuperInstance || getReceiverKind() == SuperClass)
  1328.       return QualType::getFromOpaquePtr(getReceiverPointer());
  1329.  
  1330.     return QualType();
  1331.   }
  1332.  
  1333.   void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper) {
  1334.     Kind = IsInstanceSuper? SuperInstance : SuperClass;
  1335.     SuperLoc = Loc;
  1336.     setReceiverPointer(T.getAsOpaquePtr());
  1337.   }
  1338.  
  1339.   Selector getSelector() const;
  1340.  
  1341.   void setSelector(Selector S) {
  1342.     HasMethod = false;
  1343.     SelectorOrMethod = reinterpret_cast<uintptr_t>(S.getAsOpaquePtr());
  1344.   }
  1345.  
  1346.   const ObjCMethodDecl *getMethodDecl() const {
  1347.     if (HasMethod)
  1348.       return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod);
  1349.  
  1350.     return nullptr;
  1351.   }
  1352.  
  1353.   ObjCMethodDecl *getMethodDecl() {
  1354.     if (HasMethod)
  1355.       return reinterpret_cast<ObjCMethodDecl *>(SelectorOrMethod);
  1356.  
  1357.     return nullptr;
  1358.   }
  1359.  
  1360.   void setMethodDecl(ObjCMethodDecl *MD) {
  1361.     HasMethod = true;
  1362.     SelectorOrMethod = reinterpret_cast<uintptr_t>(MD);
  1363.   }
  1364.  
  1365.   ObjCMethodFamily getMethodFamily() const {
  1366.     if (HasMethod) return getMethodDecl()->getMethodFamily();
  1367.     return getSelector().getMethodFamily();
  1368.   }
  1369.  
  1370.   /// Return the number of actual arguments in this message,
  1371.   /// not counting the receiver.
  1372.   unsigned getNumArgs() const { return NumArgs; }
  1373.  
  1374.   /// Retrieve the arguments to this message, not including the
  1375.   /// receiver.
  1376.   Expr **getArgs() {
  1377.     return reinterpret_cast<Expr **>(getTrailingObjects<void *>() + 1);
  1378.   }
  1379.   const Expr * const *getArgs() const {
  1380.     return reinterpret_cast<const Expr *const *>(getTrailingObjects<void *>() +
  1381.                                                  1);
  1382.   }
  1383.  
  1384.   /// getArg - Return the specified argument.
  1385.   Expr *getArg(unsigned Arg) {
  1386.     assert(Arg < NumArgs && "Arg access out of range!");
  1387.     return getArgs()[Arg];
  1388.   }
  1389.   const Expr *getArg(unsigned Arg) const {
  1390.     assert(Arg < NumArgs && "Arg access out of range!");
  1391.     return getArgs()[Arg];
  1392.   }
  1393.  
  1394.   /// setArg - Set the specified argument.
  1395.   void setArg(unsigned Arg, Expr *ArgExpr) {
  1396.     assert(Arg < NumArgs && "Arg access out of range!");
  1397.     getArgs()[Arg] = ArgExpr;
  1398.   }
  1399.  
  1400.   /// isDelegateInitCall - Answers whether this message send has been
  1401.   /// tagged as a "delegate init call", i.e. a call to a method in the
  1402.   /// -init family on self from within an -init method implementation.
  1403.   bool isDelegateInitCall() const { return IsDelegateInitCall; }
  1404.   void setDelegateInitCall(bool isDelegate) { IsDelegateInitCall = isDelegate; }
  1405.  
  1406.   SourceLocation getLeftLoc() const { return LBracLoc; }
  1407.   SourceLocation getRightLoc() const { return RBracLoc; }
  1408.  
  1409.   SourceLocation getSelectorStartLoc() const {
  1410.     if (isImplicit())
  1411.       return getBeginLoc();
  1412.     return getSelectorLoc(0);
  1413.   }
  1414.  
  1415.   SourceLocation getSelectorLoc(unsigned Index) const {
  1416.     assert(Index < getNumSelectorLocs() && "Index out of range!");
  1417.     if (hasStandardSelLocs())
  1418.       return getStandardSelectorLoc(
  1419.           Index, getSelector(), getSelLocsKind() == SelLoc_StandardWithSpace,
  1420.           llvm::ArrayRef(const_cast<Expr **>(getArgs()), getNumArgs()),
  1421.           RBracLoc);
  1422.     return getStoredSelLocs()[Index];
  1423.   }
  1424.  
  1425.   void getSelectorLocs(SmallVectorImpl<SourceLocation> &SelLocs) const;
  1426.  
  1427.   unsigned getNumSelectorLocs() const {
  1428.     if (isImplicit())
  1429.       return 0;
  1430.     Selector Sel = getSelector();
  1431.     if (Sel.isUnarySelector())
  1432.       return 1;
  1433.     return Sel.getNumArgs();
  1434.   }
  1435.  
  1436.   void setSourceRange(SourceRange R) {
  1437.     LBracLoc = R.getBegin();
  1438.     RBracLoc = R.getEnd();
  1439.   }
  1440.  
  1441.   SourceLocation getBeginLoc() const LLVM_READONLY { return LBracLoc; }
  1442.   SourceLocation getEndLoc() const LLVM_READONLY { return RBracLoc; }
  1443.  
  1444.   // Iterators
  1445.   child_range children();
  1446.  
  1447.   const_child_range children() const;
  1448.  
  1449.   using arg_iterator = ExprIterator;
  1450.   using const_arg_iterator = ConstExprIterator;
  1451.  
  1452.   llvm::iterator_range<arg_iterator> arguments() {
  1453.     return llvm::make_range(arg_begin(), arg_end());
  1454.   }
  1455.  
  1456.   llvm::iterator_range<const_arg_iterator> arguments() const {
  1457.     return llvm::make_range(arg_begin(), arg_end());
  1458.   }
  1459.  
  1460.   arg_iterator arg_begin() { return reinterpret_cast<Stmt **>(getArgs()); }
  1461.  
  1462.   arg_iterator arg_end()   {
  1463.     return reinterpret_cast<Stmt **>(getArgs() + NumArgs);
  1464.   }
  1465.  
  1466.   const_arg_iterator arg_begin() const {
  1467.     return reinterpret_cast<Stmt const * const*>(getArgs());
  1468.   }
  1469.  
  1470.   const_arg_iterator arg_end() const {
  1471.     return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs);
  1472.   }
  1473.  
  1474.   static bool classof(const Stmt *T) {
  1475.     return T->getStmtClass() == ObjCMessageExprClass;
  1476.   }
  1477. };
  1478.  
  1479. /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
  1480. /// (similar in spirit to MemberExpr).
  1481. class ObjCIsaExpr : public Expr {
  1482.   /// Base - the expression for the base object pointer.
  1483.   Stmt *Base;
  1484.  
  1485.   /// IsaMemberLoc - This is the location of the 'isa'.
  1486.   SourceLocation IsaMemberLoc;
  1487.  
  1488.   /// OpLoc - This is the location of '.' or '->'
  1489.   SourceLocation OpLoc;
  1490.  
  1491.   /// IsArrow - True if this is "X->F", false if this is "X.F".
  1492.   bool IsArrow;
  1493.  
  1494. public:
  1495.   ObjCIsaExpr(Expr *base, bool isarrow, SourceLocation l, SourceLocation oploc,
  1496.               QualType ty)
  1497.       : Expr(ObjCIsaExprClass, ty, VK_LValue, OK_Ordinary), Base(base),
  1498.         IsaMemberLoc(l), OpLoc(oploc), IsArrow(isarrow) {
  1499.     setDependence(computeDependence(this));
  1500.   }
  1501.  
  1502.   /// Build an empty expression.
  1503.   explicit ObjCIsaExpr(EmptyShell Empty) : Expr(ObjCIsaExprClass, Empty) {}
  1504.  
  1505.   void setBase(Expr *E) { Base = E; }
  1506.   Expr *getBase() const { return cast<Expr>(Base); }
  1507.  
  1508.   bool isArrow() const { return IsArrow; }
  1509.   void setArrow(bool A) { IsArrow = A; }
  1510.  
  1511.   /// getMemberLoc - Return the location of the "member", in X->F, it is the
  1512.   /// location of 'F'.
  1513.   SourceLocation getIsaMemberLoc() const { return IsaMemberLoc; }
  1514.   void setIsaMemberLoc(SourceLocation L) { IsaMemberLoc = L; }
  1515.  
  1516.   SourceLocation getOpLoc() const { return OpLoc; }
  1517.   void setOpLoc(SourceLocation L) { OpLoc = L; }
  1518.  
  1519.   SourceLocation getBeginLoc() const LLVM_READONLY {
  1520.     return getBase()->getBeginLoc();
  1521.   }
  1522.  
  1523.   SourceLocation getBaseLocEnd() const LLVM_READONLY {
  1524.     return getBase()->getEndLoc();
  1525.   }
  1526.  
  1527.   SourceLocation getEndLoc() const LLVM_READONLY { return IsaMemberLoc; }
  1528.  
  1529.   SourceLocation getExprLoc() const LLVM_READONLY { return IsaMemberLoc; }
  1530.  
  1531.   // Iterators
  1532.   child_range children() { return child_range(&Base, &Base+1); }
  1533.  
  1534.   const_child_range children() const {
  1535.     return const_child_range(&Base, &Base + 1);
  1536.   }
  1537.  
  1538.   static bool classof(const Stmt *T) {
  1539.     return T->getStmtClass() == ObjCIsaExprClass;
  1540.   }
  1541. };
  1542.  
  1543. /// ObjCIndirectCopyRestoreExpr - Represents the passing of a function
  1544. /// argument by indirect copy-restore in ARC.  This is used to support
  1545. /// passing indirect arguments with the wrong lifetime, e.g. when
  1546. /// passing the address of a __strong local variable to an 'out'
  1547. /// parameter.  This expression kind is only valid in an "argument"
  1548. /// position to some sort of call expression.
  1549. ///
  1550. /// The parameter must have type 'pointer to T', and the argument must
  1551. /// have type 'pointer to U', where T and U agree except possibly in
  1552. /// qualification.  If the argument value is null, then a null pointer
  1553. /// is passed;  otherwise it points to an object A, and:
  1554. /// 1. A temporary object B of type T is initialized, either by
  1555. ///    zero-initialization (used when initializing an 'out' parameter)
  1556. ///    or copy-initialization (used when initializing an 'inout'
  1557. ///    parameter).
  1558. /// 2. The address of the temporary is passed to the function.
  1559. /// 3. If the call completes normally, A is move-assigned from B.
  1560. /// 4. Finally, A is destroyed immediately.
  1561. ///
  1562. /// Currently 'T' must be a retainable object lifetime and must be
  1563. /// __autoreleasing;  this qualifier is ignored when initializing
  1564. /// the value.
  1565. class ObjCIndirectCopyRestoreExpr : public Expr {
  1566.   friend class ASTReader;
  1567.   friend class ASTStmtReader;
  1568.  
  1569.   Stmt *Operand;
  1570.  
  1571.   // unsigned ObjCIndirectCopyRestoreBits.ShouldCopy : 1;
  1572.  
  1573.   explicit ObjCIndirectCopyRestoreExpr(EmptyShell Empty)
  1574.       : Expr(ObjCIndirectCopyRestoreExprClass, Empty) {}
  1575.  
  1576.   void setShouldCopy(bool shouldCopy) {
  1577.     ObjCIndirectCopyRestoreExprBits.ShouldCopy = shouldCopy;
  1578.   }
  1579.  
  1580. public:
  1581.   ObjCIndirectCopyRestoreExpr(Expr *operand, QualType type, bool shouldCopy)
  1582.       : Expr(ObjCIndirectCopyRestoreExprClass, type, VK_LValue, OK_Ordinary),
  1583.         Operand(operand) {
  1584.     setShouldCopy(shouldCopy);
  1585.     setDependence(computeDependence(this));
  1586.   }
  1587.  
  1588.   Expr *getSubExpr() { return cast<Expr>(Operand); }
  1589.   const Expr *getSubExpr() const { return cast<Expr>(Operand); }
  1590.  
  1591.   /// shouldCopy - True if we should do the 'copy' part of the
  1592.   /// copy-restore.  If false, the temporary will be zero-initialized.
  1593.   bool shouldCopy() const { return ObjCIndirectCopyRestoreExprBits.ShouldCopy; }
  1594.  
  1595.   child_range children() { return child_range(&Operand, &Operand+1); }
  1596.  
  1597.   const_child_range children() const {
  1598.     return const_child_range(&Operand, &Operand + 1);
  1599.   }
  1600.  
  1601.   // Source locations are determined by the subexpression.
  1602.   SourceLocation getBeginLoc() const LLVM_READONLY {
  1603.     return Operand->getBeginLoc();
  1604.   }
  1605.   SourceLocation getEndLoc() const LLVM_READONLY {
  1606.     return Operand->getEndLoc();
  1607.   }
  1608.  
  1609.   SourceLocation getExprLoc() const LLVM_READONLY {
  1610.     return getSubExpr()->getExprLoc();
  1611.   }
  1612.  
  1613.   static bool classof(const Stmt *s) {
  1614.     return s->getStmtClass() == ObjCIndirectCopyRestoreExprClass;
  1615.   }
  1616. };
  1617.  
  1618. /// An Objective-C "bridged" cast expression, which casts between
  1619. /// Objective-C pointers and C pointers, transferring ownership in the process.
  1620. ///
  1621. /// \code
  1622. /// NSString *str = (__bridge_transfer NSString *)CFCreateString();
  1623. /// \endcode
  1624. class ObjCBridgedCastExpr final
  1625.     : public ExplicitCastExpr,
  1626.       private llvm::TrailingObjects<ObjCBridgedCastExpr, CXXBaseSpecifier *> {
  1627.   friend class ASTStmtReader;
  1628.   friend class ASTStmtWriter;
  1629.   friend class CastExpr;
  1630.   friend TrailingObjects;
  1631.  
  1632.   SourceLocation LParenLoc;
  1633.   SourceLocation BridgeKeywordLoc;
  1634.   unsigned Kind : 2;
  1635.  
  1636. public:
  1637.   ObjCBridgedCastExpr(SourceLocation LParenLoc, ObjCBridgeCastKind Kind,
  1638.                       CastKind CK, SourceLocation BridgeKeywordLoc,
  1639.                       TypeSourceInfo *TSInfo, Expr *Operand)
  1640.       : ExplicitCastExpr(ObjCBridgedCastExprClass, TSInfo->getType(),
  1641.                          VK_PRValue, CK, Operand, 0, false, TSInfo),
  1642.         LParenLoc(LParenLoc), BridgeKeywordLoc(BridgeKeywordLoc), Kind(Kind) {}
  1643.  
  1644.   /// Construct an empty Objective-C bridged cast.
  1645.   explicit ObjCBridgedCastExpr(EmptyShell Shell)
  1646.       : ExplicitCastExpr(ObjCBridgedCastExprClass, Shell, 0, false) {}
  1647.  
  1648.   SourceLocation getLParenLoc() const { return LParenLoc; }
  1649.  
  1650.   /// Determine which kind of bridge is being performed via this cast.
  1651.   ObjCBridgeCastKind getBridgeKind() const {
  1652.     return static_cast<ObjCBridgeCastKind>(Kind);
  1653.   }
  1654.  
  1655.   /// Retrieve the kind of bridge being performed as a string.
  1656.   StringRef getBridgeKindName() const;
  1657.  
  1658.   /// The location of the bridge keyword.
  1659.   SourceLocation getBridgeKeywordLoc() const { return BridgeKeywordLoc; }
  1660.  
  1661.   SourceLocation getBeginLoc() const LLVM_READONLY { return LParenLoc; }
  1662.  
  1663.   SourceLocation getEndLoc() const LLVM_READONLY {
  1664.     return getSubExpr()->getEndLoc();
  1665.   }
  1666.  
  1667.   static bool classof(const Stmt *T) {
  1668.     return T->getStmtClass() == ObjCBridgedCastExprClass;
  1669.   }
  1670. };
  1671.  
  1672. /// A runtime availability query.
  1673. ///
  1674. /// There are 2 ways to spell this node:
  1675. /// \code
  1676. ///   @available(macos 10.10, ios 8, *); // Objective-C
  1677. ///   __builtin_available(macos 10.10, ios 8, *); // C, C++, and Objective-C
  1678. /// \endcode
  1679. ///
  1680. /// Note that we only need to keep track of one \c VersionTuple here, which is
  1681. /// the one that corresponds to the current deployment target. This is meant to
  1682. /// be used in the condition of an \c if, but it is also usable as top level
  1683. /// expressions.
  1684. ///
  1685. class ObjCAvailabilityCheckExpr : public Expr {
  1686.   friend class ASTStmtReader;
  1687.  
  1688.   VersionTuple VersionToCheck;
  1689.   SourceLocation AtLoc, RParen;
  1690.  
  1691. public:
  1692.   ObjCAvailabilityCheckExpr(VersionTuple VersionToCheck, SourceLocation AtLoc,
  1693.                             SourceLocation RParen, QualType Ty)
  1694.       : Expr(ObjCAvailabilityCheckExprClass, Ty, VK_PRValue, OK_Ordinary),
  1695.         VersionToCheck(VersionToCheck), AtLoc(AtLoc), RParen(RParen) {
  1696.     setDependence(ExprDependence::None);
  1697.   }
  1698.  
  1699.   explicit ObjCAvailabilityCheckExpr(EmptyShell Shell)
  1700.       : Expr(ObjCAvailabilityCheckExprClass, Shell) {}
  1701.  
  1702.   SourceLocation getBeginLoc() const { return AtLoc; }
  1703.   SourceLocation getEndLoc() const { return RParen; }
  1704.   SourceRange getSourceRange() const { return {AtLoc, RParen}; }
  1705.  
  1706.   /// This may be '*', in which case this should fold to true.
  1707.   bool hasVersion() const { return !VersionToCheck.empty(); }
  1708.   VersionTuple getVersion() const { return VersionToCheck; }
  1709.  
  1710.   child_range children() {
  1711.     return child_range(child_iterator(), child_iterator());
  1712.   }
  1713.  
  1714.   const_child_range children() const {
  1715.     return const_child_range(const_child_iterator(), const_child_iterator());
  1716.   }
  1717.  
  1718.   static bool classof(const Stmt *T) {
  1719.     return T->getStmtClass() == ObjCAvailabilityCheckExprClass;
  1720.   }
  1721. };
  1722.  
  1723. } // namespace clang
  1724.  
  1725. #endif // LLVM_CLANG_AST_EXPROBJC_H
  1726.